C语言——顺序表详解

顺序表，与名字一样，存储的数据是物理上的连续，开辟一段空间存储数据，这个开辟空间可以是静态的，也可以是动态的，静态的顺序表有较大的缺陷，比如说如果开辟空间过小，存储的数据就不能多，如果开辟过大，又没有那么多数据可以存储进去，造成空间浪费，所以在这里主要讲解动态的顺序表。

假设顺序表中存储的数据类型是int，重命名为SLDataType。

typedef int SLDataType;

顺序表中有三个数据，一个是有效的数据的数组，一个是当前顺序表中有效数据的个数，一个是当前顺序表的最大容量。将这个结构体重命名为SL。

typedef struct SeqList
{
	SLDataType* data;
	int size;
	int capacity;
}SL;

在头文件中声明要实现功能的函数，在源文件中一一写出函数。

//声明函数

//初始化顺序表
void SeqListInit(SL* ps);

//销毁数据表
void SeqListDestory(SL* ps);

//判断顺序表是否已满
void SeqListCheckCapacity(SL* ps);

//打印顺序表中的数据
void SeqListPrint(SL* ps);

//头插
void SeqListPushFront(SL* ps, SLDataType x);

//尾插
void SeqListPushBack(SL* ps, SLDataType x);

//头删
void SeqListPopFront(SL* ps);

//尾删
void SeqListPopBack(SL* ps);

//插入中间
void SeqListInsert(SL* ps, int pos, SLDataType x);

//删除中间的数据
void SeqListErase(SL* ps, int pos);

//查找数据
int SeqListFind(SL* ps, SLDataType x);

//修改数据
void SeqListModefy(SL* ps, int pos, SLDataType x);

1.顺序表的初始化

//初始化顺序表
void SeqListInit(SL* ps)
{
	assert(ps);

	ps->data = NULL;
	ps->capacity = ps->size = 0;
}

初始化顺序表可以在这里直接开辟一段空间，也可以在后续添加数据时再动态开辟内存，在这里，我选择后者，将顺序表数据的指针置为空，将size和capacity都置为0。

2.销毁数据表

//销毁数据表
void SeqListDestory(SL* ps)
{
	assert(ps);

	free(ps->data);
	ps->data = NULL;
	ps->capacity = ps->size = 0;
}

销毁它与初始化一样，不管你在初始化的时候是直接开辟空间还是像我这样的，都是将指针置为空，将size和capacity都置为0。

3.判断顺序表是否已满

//判断顺序表是否已满
void SeqListCheckCapacity(SL* ps)
{
	assert(ps);

	if (ps->capacity == ps->size)
	{
		int Newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = realloc(ps->data, sizeof(SLDataType) * Newcapacity);

		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->data = tmp;
			ps->capacity = Newcapacity;
		}
	}
	else
	{
		return;
	}
}

如果顺序表已经满了的话就要重新开辟一段空间，使用realloc，因为我初始化顺序表没有开辟空间，因此在这里我使用三目操作符，如果ps->data是空的话就给他开辟四个SLDataType大小的空间，如果非空的话就将它的容量置为原来的二倍。

4.打印顺序表

//打印顺序表中的数据
void SeqListPrint(SL* ps)
{
	assert(ps);

	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}

这个没有什么好说的，创建变量i，遍历顺序表打印即可。

5.头插

//头插
void SeqListPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SeqListCheckCapacity(ps);

	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->data[end + 1] = ps->data[end];
		end--;
	}
	ps->data[0] = x;
	ps->size++;
}

顺序表的头插就是将所有元素都往后移，往后移数据需要从后往前进行，因为如果从前往后会将数据覆盖掉，再将这个数据放到最前面就可以了。记住要将ps->size++。

6.尾插 

//尾插
void SeqListPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	SeqListCheckCapacity(ps);

	ps->data[ps->size] = x;
	ps->size++;
}

尾插就是直接将数据放到最后，这没什么好讲的。

7.头删

//头删
void SeqListPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);

	int start = 1;
	while (start < ps->size)
	{
		ps->data[start - 1] = ps->data[start];
		start++;
	}
	ps->size--;
}

与头插相反，将第一个数据删除只需要将数据都往前移，再将ps->size--就可以了。

8.尾删

//尾删
void SeqListPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);

	ps->size--;
}

 尾删只需要将ps->size--就可以了，不需要将最后一个数据置为0，因为如果顺序表中存储的数据类型不是int，而是double、char或者是结构体，置为0就会出问题。

9.插入中间

//插入中间
void SeqListInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos < ps->size);

	SeqListCheckCapacity(ps);

	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->data[end + 1] = ps->data[end];
		end--;
	}
	ps->data[pos] = x;
	ps->size++;
}

与尾插类似，就是将pos之后的数据都往后移，再将数据放到pos处即可。记住要先确认空间足够，调用SeqListCheckCapacity函数，最后将ps->size++。

10.删除中间

//删除中间的数据
void SeqListErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos < ps->size);

	int start = pos + 1;
	while (start < ps->size)
	{
		ps->data[start - 1] = ps->data[start];
		start++;
	}
	ps->size--;
}

 将pos后面的数据都往前移，再将ps->size--就行了。

11.查找数据

//查找数据
int SeqListFind(SL* ps, SLDataType x)
{
	assert(ps);

	for (int i = 0; i < ps->size; i++)
	{
		if (ps->data[i] == x)
			return i;
	}
	
	return -1;
}

 从前往后遍历顺序表，如果找到了就返回它的下标，找不到就返回-1。

12.修改数据

//修改数据
void SeqListModefy(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos < ps->size);

	ps->data[pos] = x;
}

得到要修改数据的下标，直接重置即可。

以上就是顺序表的一些基本功能。