静态顺序表的实现（增删查改排序）

顺序表的各种操作实现

#define _CRT_SECURE_NO_WARNINGS 1

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef int DataType;

#define N 100

//结构体定义
typedef struct SeqList
{
	DataType array[N]; // 数组
	size_t size;       // 有效数据的个数
}SeqList;

void InitSeqList(SeqList* s);
void PushBack(SeqList* s, DataType x);
void PopBack(SeqList* s);
void PushFront(SeqList* s, DataType x);
void PopFront(SeqList* s);
void Insert(SeqList* s, size_t pos, DataType x);
void Erase(SeqList* s, size_t pos);
int Find(SeqList* s, DataType x);
void Modify(SeqList* s, size_t pos, DataType x);
int Remove(SeqList* s, DataType x);
int RemoveAll(SeqList* s, DataType x);
void BubbleSort(SeqList* s);
void SelectSort(SeqList* s);
void SelectSort_OP(SeqList* s);
int BinarySearch(SeqList* s, DataType x);

//初始化

void InitSeqList(SeqList* s)
{
	memset(s->array, 0, sizeof(DataType)*N);
	s->size = 0;
}

//打印顺序表

void PrintSeqlist(SeqList *s)
{
	for (size_t i = 0; i < s->size; ++i)
	{
		printf("%d", s->array[i]);
	}
	printf("\n");
}

//尾插

void PushBack(SeqList* s, DataType x)
{
	assert(s);
	if (s->size == N)
	{
		printf("array is full");
		return;
	}
	s->array[s->size] = x;
	s->size++;
}

//尾删

void PopBack(SeqList* s)
{
	int start = 0;
	if (s->size == 0)
	{
		printf("SeqList is kong");
		return;
	}
	s->array[s->size-1] = 0;
	s->size--;
}

//头插

void PushFront(SeqList* s, DataType x)
{
	assert(s);
	if (s->size == 0)
	{
		printf("SeqList is kong");
	}
	for (int end = s->size-1; end >= 0; --end)
	{
		s->array[end + 1] = s->array[end];
	}
	s->array[0] = x;
	s->size++;
}

//头删

void PopFront(SeqList* s)
{
	assert(s);
	if (s->size = "")
	{
		printf("SeqLsit is kong");
	}
	for (int start = 0; start < s->size; ++start)
	{
		s->array[start] = s->array[start + 1];
	}
	s->size--;
}

//指定位置插入

void Insert(SeqList* s, size_t pos, DataType x)
{
	assert(s);
	if (s->size == N)
	{
		printf("arrar is full");
	}
	for (size_t end = s->size; end >= pos; --end)
	{
		s->array[end + 1] = s->array[end];
	}
	s->array[pos] = x;
	s->size++;
}

//指定位置删除

void Erase(SeqList* s, size_t pos)
{
	assert(s);
	if (s->size == 0)
	{
		printf("array is kong");
	}
	for (int mid = pos; mid < s->size; ++mid)
	{
		s->array[mid] = s->array[mid + 1];
	}
	s->size--;
}

//查找数据

int Find(SeqList* s, DataType x)
{
	assert(s);
	if (s->size == 0)
	{
		printf("array is kong");
	}
	for (int start = 0; start < s->size; ++start)
	{
		if (s->array[start] == x)
		{
			return start;
		}
	}
	return 0;
}

//修改指定位置

void Modify(SeqList* s, size_t pos, DataType x)
{
	assert(s);
	if (s->size == 0)
	{
		printf("array is kong");
	}
	s->array[pos] = x;
}

//删除

int Remove(SeqList* s, DataType x)
{
	assert(s);
	if (s->size == 0)
	{
		printf("array is kong");
	}
	int rel = Find(s, x);
	if (rel != 0)
	{
		Erase(s, rel);
		return 0;
	}
	else
	{
		return -1;
	}
	/*if (rel == 0)
	{
		return 0;
	}
	if (rel != 0)
	{
		for (int pos = rel; pos < s->size; ++pos)
		{
			s->array[pos] = s->array[pos + 1];
		}
		return 1;
	}
	s->size--;*/
}

//删除所有数据

int RemoveAll(SeqList* s, DataType x)
{
	int ret;
	assert(s);
	ret = Remove(s, x);
	while (ret == 0 && Remove(s, x) == 0)
	{
		;
	}
	return ret;
}

void Swap(DataType* left, DataType* right)
{
	DataType temp = *left;
	*left = *right;
	*right = temp;
}


//顺序表冒泡排序
void BubbleSort(SeqList* s)
{
	int start = 0;
	int end = 0;
	assert(s);
	for (end = s->size; end > 0; --end)
	{
		int i = 0;
		while (start+1 < end )
		{
			Swap(s->array + start, s->array + start + 1);
			i = 1;
		}
		++start;
	}
}



//顺序表选择排序
void SelectSort(SeqList* s)
{
	size_t start = 0;
	assert(s);

	for (; start < s->size; ++start)
	{
		size_t i = start;
		size_t min = start;
		for (; i < s->size; ++i)
		{
			if (s->array[min]>s->array[i])
			{
				min = i;
			}
		}
		Swap(s->array + start, s->array + min);
	}
}

//选择排序从头从尾向中间走

void SelectSort_OP(SeqList* s)
{
	size_t start = 0;
	size_t finish = s->size - 1;
	assert(s);
	while (start < finish)
	{
		size_t i = start;
		size_t min = start;
		size_t max = start;
		while (i <= finish)
		{
			if (s->array[i] < s->array[min])
			{
				min = i;
			}
			if (s->array[i]>s->array[max])
			{
				max = i;
				++i;
			}
			Swap(s->array + start, s->array + min);
			if (start == max)
			{
				max = min;
			}
			Swap(s->array + finish, s->array + max);
			start++;
			finish--;
		}
	}
}

//二分查找

int BinarySearch(SeqList* s, DataType x)
{
	//size_t pos = (s -> size) / 2;
	int left = 0;
	int right = s->size;
	assert(s);
	if (s->size == 0)
	{
		printf("array is kong");
	}

	while (left <= right)
	{
		size_t pos = (left + right) / 2;

		if (x == s->array[pos])
		{
			return pos;
		}
		else if (x < s->array[pos])
		{
			right = pos - 1;
		}
		else if (x>s->array[pos])
		{
			left = pos + 1;
		}
	}
	return 0;
}

void TestSeqlist()
{
	SeqList s;
	InitSeqList(&s);
	PushBack(&s, 1);
	PushBack(&s, 2);
	PushBack(&s, 3);
	PushBack(&s, 4);
	PushBack(&s, 5);
	PushBack(&s, 6);

	PrintSeqlist(&s);

	int pos = BinarySearch(&s, 2);
	//Remove(&s, 3);
	//int pos = Find(&s, 2);

	printf("%d\n", pos);
	//PushFront(&s, 0);

	//Insert(&s, 2, 9);

	//PrintSeqlist(&s);

}