C语言实现简单数据结构——顺序表和栈

• 盆友们，他来了他来了，C语言实现简单数据结构来了！

今天要给大家分享的是顺序表和栈的知识，本来这是两个知识，但是栈的功能是通过顺序表进行模拟实现的，所有今天就一起给大家分析了~

目录

1、线性表

2、顺序表

3、栈

---

1、线性表

什么是线性表呢？

        线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表（这个咱们下一篇博客见）、栈、队列（会和链表一起分享）、字符串...

        线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

        接下来就来开始主要内容了~

2、顺序表

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

2.2、顺序表可以分为以下两类：

• 静态的顺序表，即一开始就固定顺序表的大小（以下是静态顺序表的存储）

#define N 10
typedef int SLData;
typedef struct SeqList
{
    SLData array[N];//给定数组长度，后面大小不能再动态改变
    int size;//顺序表当前的有效数据个数
}SeqList;

• 动态的顺序表，即当空间不够时，动态扩大空间，而不是一开始就固定大小（以下是动态顺序表的存储）

typedef int SLDtata;
typedef struct SeqList
{
    SLData* a;//记录动态顺序表的头
    int size;//顺序表中有效数据的个数
    int capacity;//当前顺序表的容量，空间不够可以进行动态扩容
}SeqList;

        一般情况下，我们多用动态结构来实现顺序表，所以，接下来我将带领uu们一起完成动态顺序表的实现~

2.3、动态顺序表的实现

Step1：列出我们需要实现的接口：

ps：本文代码中的命名风格与MYSQL风格一致，希望大家能够看懂

// 基本增删查改接口
// 顺序表初始化
void SeqListInit(SeqList* ps, size_t capacity);
// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* ps);
// 顺序表尾插
void SeqListPushBack(SeqList* ps, SLDataType x);
// 顺序表尾删
void SeqListPopBack(SeqList* ps);
// 顺序表头插
void SeqListPushFront(SeqList* ps, SLDataType x);
// 顺序表头删
void SeqListPopFront(SeqList* ps);
// 顺序表查找
int SeqListFind(SeqList* ps, SLDataType x); 
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, size_t pos);
// 顺序表销毁
void SeqListDestory(SeqList* ps);
// 顺序表打印
void SeqListPrint(SeqList* ps);

Step2：接口的一一实现（关于代码如何写出来的，我会在代码块中进行注释解释，不再单独列出来，结合画图来完成接口的实现）

//初始化顺序表
void SeqListInit(SeqList* ps)
{
	assert(ps);//防止有人恶意传入NULL，在使用出入的指针的时候都要进行断言，防止出现对空指针的解引用操作
	ps->a = NULL;//防止出现野指针，将结构体中的指针置空
	ps->capacity = 0;//因为是动态顺序表，在使用前顺序表容量为空，开始使用时动态开辟空间
	ps->size = 0;//使用前顺序表中无有效数据
}

//检查空间够不够
void CheckCapacity(SeqList* ps)
{
    assert(ps);//与上文同理
	if (ps->capacity == ps->size)//ps->size指向的是有效数据的下一个，当
	{
		int count = ps->capacity > 0 ? 2 * ps->capacity : 4;
		SLDateType* p = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * count);
		if (p == NULL)
		{
			perror("CheckCapacity::malloc");
			return;
		}
		ps->a = p;
		ps->capacity = count;
	}
}

//尾插数据
void SeqListPushBack(SeqList* ps, SLDateType x)
{
    assert(ps);//与上文同理
	CheckCapacity(ps);//每次插入数据时，无论是头插还是尾插，都要检查当前的容量是否可以进行插入操作
	assert(ps);
	ps->a[ps->size] = x;//因为ps->size指向的是有效数据的下一个位置，直接在数组的这个位置放入要插入的数据
	ps->size++;//插入数据后，有效数据的个数增加，ps->size增加1
}

//尾删数据
void SeqListPopBack(SeqList* ps)
{
	assert(ps);//与上文同理
	ps->size--;//在这里可能会有疑问，我们尾删数据时，我们只需要让ps->size减一，当下一次插入数据时，就把后一个覆盖了，即使后面不插入数据，有效数据只记录到ps->size的前一个，也就是说完成了尾删
}

//头插数据
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	assert(ps);//与上文同理
	CheckCapacity(ps);//检查数组是否已满，方便后面进行数据的插入操作
    //现在要实现的功能是头插，对于数组，想要在它的头插入一个数据，只能将后面的数依次后移，将头的位置空出来，才能进行插入
    //同时，要从最后一个数据开始往后移，如果从第一个数据开始往后挪动，前一个数据会覆盖掉后一个数据，那么后一个数据就丢失了
	int end = ps->size;//得到当前最后一个有效数据的下标，作为控制变量控制数组数据的移动
    //以下是常规移动数据操作，这里就不赘述了
	while (end > 0)
	{
		ps->a[end] = ps->a[end - 1];
		end--;
	}
	ps->a[0] = x;//将我们想要插入的数据赋给数组首元素
	ps->size++;//有效数据增加，有效数据的下标相应加一
}

//头删数据
void SeqListPopFront(SeqList* ps)
{
	assert(ps);//与上文同理
    //进行头删只需要从头开始，后一个数据覆盖的前一个数据就可以
    //可不敢与头插相同从后往前覆盖，这样会造成数据丢失，不理解的同学可以自己画图看
    //常规移动数据操作，不再赘述
	size_t start = 0;
	while (start < ps->size-1)
	{
		ps->a[start] = ps->a[start + 1];
		start++;
	}
	ps->size--;//删除一个有效数据后，有效数据的最大下标相应减小
}

//查找指定数
int SeqListFind(SeqList* ps, SLDateType x)
{
	assert(ps);//与上文同理
    //最常规的操作，遍历数组找目标数字
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;//找着了返回目标数字的下标，方便进行函数的链式访问
		}
	}
	return -1;//没找着返回-1，方便函数使用者进行判断
}

//在任意位置插入数据
//这里的函数形参pos就可以通过调用上一个函数得到，可以进行函数的链式访问
void SeqListInsert(SeqList* ps, size_t pos, SLDateType x)
{
	assert(ps);//与上文同理
	assert(pos >= 0 && pos <= ps->size);//防止有人恶意传入不是合法数组下标的数
	CheckCapacity(ps);//插入数据前都要检查数组是否已满
    //插入的思想为将pos位置后的数据，包括pos位置的数据，依次向后移，将pos位置空出来，方便数据的插入
    //总体的思路与头插相似，不过不是移动全部数据，而是pos位置及以后的数据
	int end = ps->size;
	while (end > pos)
	{
		ps->a[end] = ps->a[end - 1];
		end--;
	}
	ps->a[pos] = x;//插入给定数据
	ps->size++;//有效数据增加，最大下标也增加
}
//我们实现了任意位置的插入，那么头插，尾插也属于任意位置的插入
//我们可以通过复用本函数来实现头插和尾插
//具体怎么复用实现比较简单，这里也不赘述了

//在任意位置删除数据
void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps);//与上文同理
	assert(pos >= 0 && pos < ps->size);//与上文同理
	CheckCapacity(ps);//与上文同理
    //整体思想与头删的思想很类似
    //将pos后面的数据依次向前移，覆盖掉前一个数据，再让ps->size减一就完成了
	int start = pos;
	while (start < ps->size-1)
	{
		ps->a[start] = ps->a[start + 1];
		start++;
	}
	ps->size--;
}
//同样的，我们实现了任意位置的删除，那么头删和尾删也可以通过复用本函数来完成
//怎样复用实现此文不赘述，uu们自己试一试

//释放动态开辟的内存
//在我的上一篇将动态开辟的博客里讲过，如果不对动态开辟的空间进行正确地释放，将会造成内存泄漏的问题
void SeqListDestory(SeqList* ps)
{
	assert(ps);//与上文同理
	free(ps->a);//因为是用数组实现顺序表，数组的物理空间的连续的，直接释放就好了
	ps->a = NULL;//防止出现野指针
    //销毁后，容量和有效数据的下标都该置零
	ps->capacity = 0;
	ps->size = 0;
}

//打印数据
//为了便于调试我们的顺序表，我们通常会打印我们的顺序表的结果是否符合预期
void SeqListPrint(SeqList* ps)
{
	assert(ps);//与上文同理
    //遍历数组进行打印
	for (size_t i = 0; i < (ps->size); i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

以上就是顺序表的相关接口的实现代码了，代码这种东西还是要自己上手敲才能有收获~

Step3：接口函数的调用，这个就不用多说了，敲一个main函数来调用相应函数即可

以上就是顺序表的内容的全部分享了，这时候就有人会想，顺序表有什么用呢？接下来就给大家再介绍一个新知识——栈

3、栈

3.1、栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

• 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
• 出栈：栈的删除操作叫做出栈。出数据也在栈顶。

 栈的基本知识了解了之后，我们在了解顺序表的基础上再来实现栈就非常容易了

3.2、栈的实现

栈不是只能用顺序表实现，也可以用链表（这个我下篇博客写），两者比较下来，用顺序表来实现更优，咱就用顺序表来实现一下

Step1：列出我们需要实现的接口：

// 下面是定长的静态栈的结构，实际中一般不实用，所以我们主要实现下面的支持动态增长的栈
typedef int STDataType;
#define N 10
typedef struct Stack
{
     STDataType a[N];
 i    nt top; // 栈顶
}Stack;
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
     STDataType* a;
     int top; // 栈顶
     int capacity; // 容量
}Stack;
// 初始化栈
void StackInit(Stack* ps); 
// 入栈
void StackPush(Stack* ps, STDataType data); 
// 出栈
void StackPop(Stack* ps); 
// 获取栈顶元素
STDataType StackTop(Stack* ps); 
// 获取栈中有效元素个数
int StackSize(Stack* ps); 
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps); 
// 销毁栈
void StackDestroy(Stack* ps); 

Step2：接口的一一实现

//初始化栈
void StackInit(ST* ps)
{
	assert(ps);//防止调用函数时恶意传入NULL
	ps->capacity = 0;
	ps->top = 0;//栈顶和容量都为0
	ps->a = NULL;//置空，防止出现野指针
}

//数据入栈
void StackPush(ST* ps, Datatype x)
{
	assert(ps);//与上文同理
	if (ps->capacity == ps->top)
	{
		int newcapacity = ps->capacity == 0 ? 4 : (ps->capacity) * 2;
		Datatype* tmp = (Datatype*)realloc(ps->a, sizeof(Datatype) * newcapacity);
		if (tmp == NULL)
		{
			perror("StackPop::realloc");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}//以上代码的功能为检查数组容量，并在需要时进行扩容
    //在栈的实现的过程中不将以上代码封装成一个函数的原因是只有入栈的时候会用到，其他函数接口用不着
	ps->a[ps->top] = x;
	ps->top++;//操作与顺序表相同
}

//数据出栈
void StackPop(ST* ps)
{
	assert(ps);//与上文一致
	assert(!StackEmpty(ps));//如果栈都为空了，就没有数据可以出了
	ps->top--;//操作和顺序表一致
}

//判断栈是否为空
//如果C语言中想要使用bool类型变量，记得包含<stdbool.h>的头文件
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;//当栈顶都为空了，那么栈必然已经空了
}

//获得栈顶元素
Datatype StackTop(ST* ps)
{
	assert(ps);//与上文同理
	assert(!StackEmpty(ps));//栈都为空了，栈里没有元素的，是取不了栈顶的
	return ps->a[ps->top - 1];//ps->top指向的是栈顶的下一个位置，所以栈顶元素的下标为ps->top-1
    //栈顶下标这个主要取决于编写者，是没有标准规定的，你咋样写着开心就咋写
}

//获取当前栈的元素数目
int StackSize(ST* ps)
{
	assert(ps);//与上文同理
	return ps->top;//ps->top是指向栈顶元素的下一个位置，但是数组的下标从零开始，所以ps->top存放的也就是栈内的元素数目了
}

//销毁栈
void StackDestory(ST* ps)
{
	assert(ps);	
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}//与顺序表的销毁操作相同

因为有了前面顺序表的基础，我们实现栈的时候会相对顺畅很多，而且，因为栈的特性限制，栈是不能遍历的，也就少了很多操作

Step3：接口函数的调用，这个就不多说了

顺序表和栈的内容就是上面的这么多了，因为两者涉及的内容知识相同，我就放在一起讲了

下一篇博客会讲链表和队列，大家敬请期待吧