【数据结构】详解顺序表（图解）

---

一、顺序表的概念

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般采用数组存储，在数组上完成数组的增删查改操作。

顺序表可分为：

1.1、静态顺序表

静态顺序表是使用定长数组存储元素。空间小了，不够用，空间大了，浪费。所以静态顺序表不实用。

#define N 10
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType a[N]; // 定长数组
	int size; // 记录存储多少个数据
}SL;
1
2
3
4
5
6
7

1.2、动态顺序表

动态顺序表是使用动态开辟的数组存储

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a; // 指向动态开辟的数组
	int size; // 记录存储多少个有效数据
	int capacity; // 空间容量大小
}SL;
1
2
3
4
5
6
7

二、接口实现

由于静态顺序表不实用，所以现实中基本都是使用动态顺序表，下面我们来实现动态顺序表

2.1、开辟一个动态顺序表及初始化

1、开辟一个动态顺序表

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a; // 指向动态开辟的数组
	int size; // 记录存储多少个有效数据
	int capacity; // 空间容量大小
}SL;
1
2
3
4
5
6
7

2、顺序表的初始化

void SLInit(SL* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}
1
2
3
4
5
6
7

将指向动态开辟的数组置为NULL。

2.2、顺序表的增容

先对空间进行判断，若空间为0，则先开辟空间，空间不够，再自动增加空间

代码实现：

void SLCheckCapacity(SL* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity*sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newCapacity;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.3、顺序表的尾插及尾删

1、顺序表的尾插

尾插即是向数组的尾部插入数据，先调用扩容函数SLCheckCapacity判断空间，当尾部空间不够时，就会自动扩容。

代码实现：

void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	// 扩容
	SLCheckCapacity(ps);
	
	ps->a[ps->size] = x;
	ps->size++;
}
1
2
3
4
5
6
7
8
9

2、顺序表的尾删

尾删就是将数据从尾部开始删除

代码实现：

void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size > 0); // 检查数据是否为NULL
	ps->size--;
}
1
2
3
4
5
6

2.4、顺序表的头插及头删

1、顺序表的头插

顺序表头插就是从数组的起始位置开始插入数据。先判断空间，再把已有的数据向后挪动，然后在头部插入数据。

代码实现：

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	// 挪动数据
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}

	ps->a[0] = x;
	ps->size++;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2、顺序表的头删

顺序表的头删是从数组的起始位置删除数据。把起始位置之后的数据向前挪动，覆盖要删除的数据

代码实现：

void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);
	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}
1
2
3
4
5
6
7
8
9
10
11
12

---

2.5、顺序表在pos处插入及删除数据

1、顺序表在pos处插入数据

顺序表在pos处插入数据是在数组中自定义位置插入数据。先判断空间，再把要插入数据位置之后的数据向后挪动，然后插入数据。

代码实现：

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

若pox=ps->size，则函数SLInsert等价于尾插
若pox=0，则函数SLInsert等价于头插

2、顺序表在pos处删除数据

顺序表在pos处删除数据是在数组中自定义位置删除数据。把自定义位置处的数据向前挪动，覆盖要删除的数据。

代码实现：

void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos < ps->size);
	// 挪动数据覆盖
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

若pox=ps->size-1，则函数SLInsert等价于尾删
若pox=0，则函数SLInsert等价于头删

2.6、顺序表的销毁及打印

1、顺序表的销毁

由于动态顺序表开辟空间，所用的函数均是动态内存函数，所以使用完后需要释放空间

代码实现：

void SLDestroy(SL* ps)
{
	assert(ps);
	if (ps->a)
	{
		free(ps->a);
		ps->a = NULL;
		ps->size = ps->capacity = 0;
	}
}
1
2
3
4
5
6
7
8
9
10

2、顺序表的打印
代码实现：

void SLPrint(SL* ps)
{
	assert(ps);

	for (int i = 0; i < ps->size; ++i)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
1
2
3
4
5
6
7
8
9
10

2.7、顺序表的查找及修改

1、顺序表的查找

从begin处开始查找

代码实现：

int SLFind(SL* ps, SLDataType x, int begin)
{
	assert(ps);
	for (int i = begin; i < ps->size; ++i)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}

	return -1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2、顺序表的修改

把pos处的数据修改成x
代码实现：

void SLModify(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	ps->a[pos] = x;
}
1
2
3
4
5
6