【结构体实现动态顺序表——c语言】

什么是顺序表？

线性表定义：
具有n个相同特性的数据元素的有限序列，线性表是
在数据存储中常见的结构并且应用广泛。
我们今天的主角：顺序表也同样是线性表的一种。

顺序表的存储方式

我们在研究顺序表时，要清楚它的逻辑结构，即我们在实现结构时，想要实现的逻辑方式。

我们可以看作是数组的存储方式（物理结构不是线性），在内存中连续存储数据，所以我们的逻辑结构正可以看作时数组的存储方式。
逻辑结构

分类

顺序表分为两种

静态顺序表
听名字就可以理解，即内存是固定不可改的顺序表。
这种顺序表在现实中非常不常用，因为内存不可改，定多了容易浪费空间，定少了容易不够用。

静态顺序表
动态顺序表可以自己来实现内存的增加和缩减，实际中也是多用这种顺序表。

动态顺序表的代码实现

顺序表的实现有多种方法，今天要挑的是结构体。
实现方法类似于通讯录青春版

顺序表变量的创建

typedef int la;
typedef struct SpList
{
	la* a;
	int sz;
	int capacity;
}sp;

这里让我们逐步分析每行代码的意义。

首先是创建了一个struct SpList结构体变量
作为我们的顺序表变量。
la* a是顺序表的存储地址，
int sz是顺序表存储的数据的数量
int capacity是顺序表的内存大小。

typedef int la对int进行重命名是为了之后方便实现其他类型顺序表的实现（将int换成double或其他类型即可）

顺序表的初始化

代码：

#define zs 10
void Initsp(sp* g)
{
	assert(g);
	g->a = (la*)malloc(sizeof(la) * zs);
	assert(g->a);
	g->capacity = zs;
	g->sz = 0;
}

思路：
1：首先对g进行assert，判断g是否为空地址。
2：用a来接受malloc开辟内存的地址，成功创建了顺序表的内存空间
3：assert(a)，提醒我们内存开辟是否成功。
4：将结构体中用来存储开辟内存大小的capacity变量赋值。
5：为g-sz赋值

顺序表的内存检查

void check_SPcapacity(sp*g)
{
	assert(g);

	if (g->capacity == g->sz)
	{
		la* d=(la*)realloc(g->a,sizeof(zs)*(g->capacity)*2);
		assert(d);
		g->a = d;
		g->capacity*=2;
	}
}

思路：
1：经典assert判断g是否为空指针，防止用户乱搞
2：判断结构体中内存存储大小与内存开辟大小进行比较
3：如果内存已满，对内存进行更大的开辟并进行assert，
提醒是否开辟成功，最后再将g中的a和capacity进行赋值

顺序表的尾部删除和尾部插入

尾部计算都十分简单

//尾插
void SLpushback(sp* g,int x)
{
	assert(g);
	g->sz++;
	check_SPcapacity(g);
	g->a[g->sz-1] = x;
}

1：将sz++，判断内存是否满。
2：将要输入的x值放入开辟的顺序表中。

//尾删
void SLpopback(sp*g)
{
	assert(g);

	g->a[g->sz - 1] = 0;
	g->sz--;
}

1：将尾部的数据改写为0；
2：将sz–；

顺序表的头插和头删

这个头插和头删可比尾部算法难多了。

头插

思路

1：sz++判断内存是否足够右移。
2：将数据从最后面右移，最后在最前面插入0

代码

void SLpushfront(sp*g,int x)
{
	assert(g);

	g->sz++;
	check_SPcapacity(g);
	for (int i = g->sz-1; i >0; i--)
	{
		g->a[i] = g->a[i - 1];
	}
	g->a[0] = x;
}

头删

思路

1：从右边将数据左移
2：sz–

代码

void SLpopfront(sp* g)
{
	assert(g);

	for (int i = 1; i < g->sz;i++)
	{
		g->a[i - 1] = g->a[i];
	}
	g->sz--;
}

打印数据

这个思路简单，所以略（懒）了。
代码

void SpPrintf(sp*g)
{
	assert(g);

	for (int i = 0; i < g->sz; i++)
	{
		printf("%d ", g->a[i]);
	}
	printf("\n");
}

销毁顺序表

在我们结束程序运行后，需要将开辟的空间还给系统。
所以我们需要创建于给销毁内存的函数。
代码

void destroySP(sp* g)
{
	assert(g);

	free(g->a);
	g->a = NULL;
	g->sz = 0;
	g->capacity = 0;
}

思路：
1：经典断言
2：将a指向的空间free，并且a置空，sz和capacity皆赋值为0；、

总代码

头文件

#include<stdio.h>
#include<assert.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
#define zs 10
typedef int la;

typedef struct SpList
{
	la* a;
	int sz;
	int capacity;
}sp;
void SpPrintf(sp*g);
void SLpopfront(sp* g);
void check_SPcapacity(sp*g);
void SLpushfront(sp* g);
void SLpopback(sp*g);
void SLpushback(sp*g);

函数实现部分

#include"true.h"



void Initsp(sp* g)
{
	assert(g);
	g->a = (la*)malloc(sizeof(zs) * zs);
	assert(g->a);
	g->capacity = zs;
	g->sz = 0;
}
void SLpopfront(sp* g)
{
	assert(g);

	for (int i = 1; i < g->sz;i++)
	{
		g->a[i - 1] = g->a[i];
	}
	g->sz--;
}

void SLpushfront(sp*g,int x)
{
	assert(g);

	g->sz++;
	check_SPcapacity(g);
	for (int i = g->sz-1; i >0; i--)
	{
		g->a[i] = g->a[i - 1];
	}
	g->a[0] = x;
}

void SLpushback(sp* g,int x)
{
	assert(g);
	g->sz++;
	check_SPcapacity(g);
	g->a[g->sz-1] = x;
}
void SLpopback(sp*g)
{
	assert(g);

	g->a[g->sz - 1] = 0;
	g->sz--;
}

void SpPrintf(sp*g)
{
	assert(g);

	for (int i = 0; i < g->sz; i++)
	{
		printf("%d ", g->a[i]);
	}
	printf("\n");
}
void check_SPcapacity(sp*g)
{
	assert(g);

	if (g->capacity == g->sz)
	{
		la* d=(la*)realloc(g->a,sizeof(la)*(g->capacity)*2);
		assert(d);
		g->a = d;
		g->capacity*=2;
	}
}

void destroySP(sp* g)
{
	assert(g);

	free(g->a);
	g->a = NULL;
	g->sz = 0;
	g->capacity = 0;
}

测试部分（随便自己修改）

#include"true.h"

void test1(sp* sp1)
{
	Initsp(sp1);
	SLpushback(sp1,1);
	SLpushback(sp1,2);
	SLpushback(sp1,3);
	SLpushback(sp1,4);
	SpPrintf(sp1);
	SpPrintf(sp1);
	destroySP(sp1);

}
int main()
{
	sp s1;
	test1(&s1);
	return 0;
}