数据结构 - 顺序表

  在这里我们先把基础的概念的认知一下：线性表

  顺序表和链表都是线性表，有必要在这里说一下：

线性表，就是有线性结构的表，那么什么是线性结构呢？线性结构是有n个元素的有序集合。

具有如下四个特征：

1.集合中必须存在唯一 一个”第一个元素“.

2.集合中必须存在唯一 一个”最后一个元素“.

3.除最后一个元素外，其它每个元素都有”后继“.

4.除第一个元素外，其他每个元素都有”前继“.

　　如集合（a1,a2,a3,.....,an）,a1为第一个元素，an为最后一个元素，此集合极为一个线性结构的集合。a2是a1的的后继。而a1是a2的前继，但a1本身并没有前继，因为它是第一个元素，an没有后继，因为它是最后一个元素.

　　相对应于线性结构，非线性结构的逻辑特征是一个结点元素可能对应多个直接前驱和多个后驱。

　　常用的线性结构有：数组，顺序表，链表，栈，队列，双队列，串。

        非线性结构有：树、图等。

说的很多，总而言之就是一个集合中必须要有大于等于两个元素，而且每个元素之间都有关系（前继，后继），既可以通过这个元素找到它的前一个元素和后一个元素（两个边界点除外）.

线性表是一种逻辑结构，只是体现在逻辑上是连续的，但实际集合本身的内容存储可能并不连续.比如链表。后面会讲.

有了基础的概念，那么什么是顺序表呢？

顺序表是在计算机内存中以数组的形式保存的线性表，是指用一块连续的存储单元，来依次存储数据的线性结构.说白了就是：顺序表就是数组。

那这里会涉及一些顺序的基本操作：

1. 顺序表的创建
2. 顺序表的初始化
3. 顺序表的打印
4. 顺序表的销毁
5. 顺序表的插入（头插、尾插、指定位置插入）
6. 顺序表的删除（头删、尾删、指定位置删除）
7. 顺序表的查找
8. 顺序表的容量检查

   1.顺序表的创建

   想想操作数据首先得有一个数组来保存这些数据，所以我们需要建立一个数组，当然只有数组也不行，你得知道当前的数组容量（大小）和数组的总大小，万一当然数组的大小大于数组的总大小了，那不就越界了吗，对吧，所以顺序表一共需要三种数据：数组、当前大小、数组总大小.

结构体如下：

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a;//数组
	size_t size;//顺序表当前大小
	size_t capacity;//顺序表总大小
}SeqList;

因为以后的数组类型并不一定是int类型，所以我们把int重命名为SLDataType，以后想要更改数据类型，比如想要更换成char类型，就直接把int改为char就可以了.size_t是无符号整型的类型，因为它们的大小一定是大于等于0的.

2.顺序表的初始化

我们只创建了顺序表，但是里面的值是随机值，我们此时要对它进行初始化.

这里我们用到一个函数，assert函数，即断言.每次将结构体传入函数的时候，我们都对它进行断言，以防意外（错误）发生，如结构体为空.

初始化的函数名我们用SeqListInit来表示SeqList为顺序表的意思，Init为初始化的意思，具体如下：

//初始化
void SeqListInit(SeqList* ps)
{
	assert(ps != NULL);//断言传进来的结构体是否为空
	ps->a = NULL;//将数组首地址置为空
	ps->size = ps->capacity = 0;//将数组的当前大小和总大小置为0
}

3.顺序表的打印

无非就是将数组里的内容全部输出出来，数量为ps->size个，这里就不再过多解释.

代码如下：

//打印顺序表
void SeqListPrint(SeqList* ps)
{
	assert(ps != NULL);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps ->a[i]);
	}
}

4.顺序表的销毁

当我们程序结束的时候，因为在程序执行过程中开辟了一些空间，所以我们需要释放掉它.

也就是销毁，相当于不存在了.代码如下：

void SeqListDestory(SeqList* ps)
{
	assert(ps != NULL);
	free(ps->a);//将数组a开辟的空间释放
	ps->a = NULL;//将a所指向的空间置为空（最最最好置为空，不置空可能会导致一些野指针问题）
	ps->size = ps->capacity = 0;
}

5.顺序表的插入 - 尾插

这个相对简单，只需要在数组最后添加元素即可，然后让size++，当然插入前要检查一下是否数组的当前容量已经大于等于数组总容量了.如果大于等于则需要给原数组扩容处理。那我们先写检查容量函数再写尾插.

	if (ps->size == ps->capacity)
	{
		int NewCapacity = (ps->capacity == 0) ? 4 : ps->capacity * 2;//这句话意思是说如果数组总大小是0，则我们先把它的容量设置为4，如果不为0，则是扩大为原容量的2倍
		SLDataType* tmp = realloc(ps->a, (NewCapacity * 2) * sizeof(SLDataType));//知道了新的数组容量，那我们需要扩容一下数组，即realloc扩增一下，并将新扩增好的数组存放到tmp中
		if (tmp == NULL)//如果tmp等于空，说明创建失败，结束程序.
		{
			printf("realloc fail\n");
			exit(-1);
		}
		ps->capacity = NewCapacity;//到这里说明数组已经扩增成功，我们将新容量替换掉原来的旧容量
		ps->a = tmp;//将新扩增好的数组赋给原来的a数组.
	}

这个时候再写尾插：

//尾插
void SeqListPushBack(SeqList* ps, SLDataType x)
{
	assert(ps != NULL);
	SLCheckCapacity(ps);//先检测当前容量是否超过数组总容量
	ps->a[ps->size] = x;//将元素赋值给数组的末位
	ps->size++;//因为新增了一个元素，让当前容量+1
}

头插：这个我们插入之前也需要检查容量，然后将元素插入到数组最前面一位，然后将原数组里的每个元素依次向后挪动一位.

代码如下：

//首插
void SeqListPushFront(SeqList* ps, SLDataType x)
{
	assert(ps != NULL);
	SLCheckCapacity(ps);//检查容量
	for (int i = ps->size; i > 0; i--)//这里要倒着进行，正着进行无法完成替换操作，自己可以画图进行理解
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[0] = x;//此时第一个元素已经被空出来的，直接插入即可
	ps->size++;
}

指定位置插入元素

和头插法类似，将需要插入的位置后面的元素依次向后挪动一个位置，再将新元素插入，当然插入前也要检查容量。

代码如下：

//指定位置插入
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x)
{
	assert(ps != NULL);
	assert(pos >= 0 && pos <= ps->size);//要插入的元素不能是小于0或者大于当前数组大小的
	SLCheckCapacity(&ps);
	int end = ps->size - 1;//将最后一个元素的下标赋给end
	while (pos <= end)//和for循环一样，从后到前依次替换，每一次end--直到到了pos位置
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;//将元素插入到pos位置
	ps->size++;
}

6.顺序表的删除 - 尾删

这个很简单，直接ps->size--即可，当前元素会被下一次插入的元素替代的，所以不会有影响的

代码如下：

void SeqListPopBack(SeqList* ps)
{
	assert(ps ->size != 0);//当前数组的大小不能为0，否则无法删除.
	ps->size--;
}

头删

这个和尾删有点相反，这次是从前向后循环，然后依次替代，就是将原数组的所有元素都想前移动一位，第一位不移动，直接被第二位覆盖掉即可。

代码如下：

//首删
void SeqListPopFront(SeqList* ps)
{
	assert(ps->size != 0);
	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}

指定位置删除

这个和头删很类似，只不过那个是头部，这个不是头部，稍微改一下即可：

代码如下：

void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps != NULL);
	assert(pos >= 0 && pos < ps->size);
	int begin = pos;
	while (begin < ps->size - 1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}

7.顺序表的查找

思路很简单，遍历整个数组，看是否与目标元素相等.

代码：

int SeqListFind(SeqList* ps, SLDataType x)
{
	assert(ps != NULL);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

这些就是顺序表的全部内容啦。完整代码如下：

需要创建三个文件：如图：

 

Seqlist.h文件：

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a;
	size_t size;
	size_t capacity;
}SeqList;
//初始化顺序表
void SeqListInit(SeqList* ps);
//打印顺序表
void SeqListPrint(SeqList* ps);
//销毁顺序表
void SeqListDestory(SeqList* ps);
//检查容量
SLCheckCapacity(SeqList* ps);
//尾插
void SeqListPushBack(SeqList* ps, SLDataType x);
//首插
void SeqListPushFront(SeqList* ps, SLDataType x);
//头删
void SeqListPopFront(SeqList* ps);
//尾删
void SeqListPopBack(SeqList* ps);
//指定位置插入
void SeqListInsert(SeqList* ps, int pos, SLDataType x);
//指定位置删除
void SeqListErase(SeqList* ps, size_t pos);
//顺序表查找
int SeqListFind(SeqList* ps, SLDataType x);

Seqlist.c文件：

#include "Seqlist.h"
//初始化
void SeqListInit(SeqList* ps)
{
	assert(ps != NULL);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}
//打印顺序表
void SeqListPrint(SeqList* ps)
{
	assert(ps != NULL);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps ->a[i]);
	}
}
//销毁顺序表
void SeqListDestory(SeqList* ps)
{
	assert(ps != NULL);
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}
//检查容量
SLCheckCapacity(SeqList* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : (ps->capacity * 2);
		SLDataType* tmp = (SLDataType*)realloc(ps->a,sizeof(SLDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("Realloc fail\n");
			exit(-1);
		}
		ps->capacity = newcapacity;
		ps->a = tmp;
	}
}
//尾插
void SeqListPushBack(SeqList* ps, SLDataType x)
{
	assert(ps != NULL);
	SLCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}
//首插
void SeqListPushFront(SeqList* ps, SLDataType x)
{
	assert(ps != NULL);
	SLCheckCapacity(ps);
	for (int i = ps->size; i > 0; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[0] = x;
	ps->size++;
}
//首删
void SeqListPopFront(SeqList* ps)
{
	assert(ps->size != 0);
	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}
//尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps ->size != 0);
	ps->size--;
}
//指定位置插入
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x)
{
	assert(ps != NULL);
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(&ps);
	int end = ps->size - 1;
	while (pos <= end)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}
//指定位置删除
void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps != NULL);
	assert(pos >= 0 && pos < ps->size);
	int begin = pos;
	while (begin < ps->size - 1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}
int SeqListFind(SeqList* ps, SLDataType x)
{
	assert(ps != NULL);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

还有一个Test.c文件，主要是进行测试的，这个里面写main函数等等

数据结构的顺序表部分的相关操作就讲完了，写法也不是唯一的，能运行过去就是最好的！

不了解的地方欢迎私信或评论区评论哦.