顺序表的C语言实现

顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

以下用C语言实现顺序表的一些操作：

void SeqInit(SeqList* pSeq);//初始化顺序表
void SeqPrint(SeqList* pSeq);//打印顺序表


void SeqPushBack(SeqList* pSeq, DataType x);//尾插
void SeqPopBack(SeqList* pSeq);//尾删
void SeqPushFront(SeqList* pSeq, DataType x);//头插
void SeqPopFront(SeqList* pSeq);//头删

void SeqInsert(SeqList* pSeq, size_t pos, DataType x);//在pos点插入
void SeqErase(SeqList* pSeq, size_t pos); //删除pos点

int SeqFind(SeqList* pSeq, DataType x);//在顺序表中查找
void SeqAt(SeqList* pSeq, size_t pos, DataType x);//替换pos位置为x

void BubbleSort(SeqList* pSeq); //冒泡排序
void SelectSort(SeqList* pSeq);//选择排序
int BinarySearch(SeqList* pSeq);//二分查找

void SeqDestory(SeqList* pSeq);//销毁顺序表

初始化顺序表

void SeqInit(SeqList* pSeq)//初始化顺序表
{
	pSeq->_size = 0;
	pSeq->_capacity = 7;
	pSeq->_a = (DataType *)malloc(pSeq->_capacity * sizeof(DataType));
	if (pSeq->_a = NULL)
	{
		printf("顺序表初始化失败");

	}
}

打印顺序表

void SeqPrint(SeqList* pSeq)//打印顺序表
{
	size_t i = 0;
	assert(pSeq);
	for (; i < pSeq->_size; i++)
	{
		printf("%d ", pSeq->_a[i]);
	}
	printf("\n");
}

尾插

void SeqPushBack(SeqList* pSeq, DataType x)//尾插
{
	size_t i = 0;
	assert(pSeq);
	for (; i < pSeq->_size; i++)
	{
		pSeq->_a[pSeq->_size] = x;
	}
    pSeq->_size++;
}

尾删

void SeqPopBack(SeqList* pSeq)//尾删
{
	assert(pSeq);
	if (pSeq->_size = 0)
		printf("顺序表里没有数据\n");
	return;
	pSeq->_size--;
}

头插

void SeqPushFront(SeqList* pSeq, DataType x)//头插
{
	size_t i = pSeq->_size;
	if (pSeq->_size >= pSeq->_capacity)
	{
		pSeq->_a = (DataType *)realloc(pSeq->_capacity ,2* sizeof(DataType));
		for (; i > 0; i--)
		{
			pSeq->_a[i] = pSeq->_a[i-1];
		}
		pSeq->_a[0] = x;
		pSeq->_size++;
	}
}

头删

void SeqPopFront(SeqList* pSeq)//头删
{
	assert(pSeq);
	size_t i = 1;
	for (; i < pSeq->_size; i++)
	{
		pSeq->_a[i - 1] = pSeq->_a[i];
	}
	pSeq->_size--;
}

在pos插入

void SeqInsert(SeqList* pSeq, size_t pos, DataType x)//在pos点插入
{
	assert(pSeq);
	size_t i = 1;
	for (; i < pos; i--)
	{
		pSeq->_a[i] = pSeq->_a[i - 1];
	}
	pSeq->_a[pos - 1] = x;
	pSeq->_size++;
}

删除pos点

void SeqErase(SeqList* pSeq, size_t pos)//删除pos点
{
	assert(pSeq);
	size_t i = pos;
	for (; i < pSeq->_size; i++)
	{
		pSeq->_a[i - 1] = pSeq->_a[i];
	}
	pSeq->_size--;
}

在顺序表里查找

int SeqFind(SeqList* pSeq, DataType x)//在顺序表中查找
{
	assert(pSeq);
	size_t i = 0;
	for (; i < pSeq->_size; i++)
	{
		if (pSeq->_a[i] = x)
		{
			return i + 1;
		}
	}
	return 0;
}

替换

void SeqAt(SeqList* pSeq, size_t pos, DataType x)//替换pos位置为x
{
	assert(pSeq);
	assert(pSeq->_a[pos] < pSeq->_size);
	pSeq->_a[pos - 1] = x;      //直接赋值即可替换
}

冒泡排序

void BubbleSort(SeqList* pSeq)//冒泡排序
{
	assert(pSeq);
	size_t i, j;
	for (i = 0; i < pSeq->_size; i++)
	{
		int tmp = 0;
		for (j = 0; j < pSeq->_size - i - 1; j++)
		{
			if (pSeq->_a[j] > pSeq->_a[j + 1])
			{
				tmp = pSeq->_a[j];
				pSeq->_a[j] = pSeq->_a[j + 1];
				pSeq->_a[j + 1] = tmp;
			}
		}
	}
    
}

选择排序

void SelectSort(SeqList* pSeq)//选择排序
{
	assert(pSeq);
	size_t min = 0;
	size_t max = 0;
	size_t left = 0;
	size_t right = pSeq->_size - 1;
	while (left<right)
	{
		for (size_t i = left; i <= right; i++)
		{
			if (pSeq->_a[min]>pSeq->_a[i])
			{
				min = i;
			}
			if (pSeq->_a[max] < pSeq->_a[i])
			{
				max = i;
			}
		}
		DataType x = pSeq->_a[min];
		pSeq->_a[min] = pSeq->_a[left];
		pSeq->_a[left] = x;
		if (max == left)
		{
			max = min;
		}
		x = pSeq->_a[max];
		pSeq->_a[max] = pSeq->_a[right];
		pSeq->_a[right] = x;
		left++;
		right--;
	}

}

二分查找

int BinarySearch(SeqList* pSeq,DataType x)//二分查找
{
	assert(pSeq);
	size_t left = 0; 
	size_t right = pSeq->_size - 1;
	while (left < right)
	{
		int mid = ((right - left) / 2) - left;
		if (pSeq->_a[mid] > x)
		{
			right = mid - 1;
		}
		if (pSeq->_a[mid] < x)
		{
			left = mid + 1;
		}
		else
		{
			return mid + 1;
		}
	}
	return 0;
}

销毁顺序表

void SeqDestory(SeqList* pSeq)//销毁顺序表
{
	assert(pSeq);
	pSeq->_size = 0;
	pSeq->_capacity = 0;
	free(pSeq->_a);//释放空间
}