嵌入式全栈开发学习笔记---数据结构（顺序表）

最新推荐文章于 2024-09-09 17:57:44 发布

Vera工程师养成记

最新推荐文章于 2024-09-09 17:57:44 发布

阅读量1k

点赞数 24

分类专栏：嵌入式全栈开发学习笔记文章标签：数据结构 stm32 linux 单片机嵌入式硬件 QT C/C++

本文链接：https://blog.csdn.net/xiaobaivera/article/details/140908804

版权

嵌入式全栈开发学习笔记专栏收录该内容

50 篇文章 12 订阅

订阅专栏

上一节我们介绍了数据结构的一般概念，并且介绍了线性结构中两种存储形式：顺序结构（顺序存储）和链式存储（链表）。

那么本节就首先来具体学习顺序结构：

顺序结构

顺序表应该支持以下操作：

初始化操作，建立一个空的顺序表

InitList(*L);

判断顺序表是否为空

ListEmpty(L);

清空顺序表

ClearList(*L);

获取第i个位置的元素，存放在e中

GetElem(L, i, *e);

查找于e相等的元素，返回元素的位置

LocateElem(L, e);

在第i个位置插入元素e

ListInsert(*L, i, e);

删除第i个位置的元素，保存在e中

ListDel(*L, i, *e);

获取顺序表的长度

ListLength(L);

注：我们后面会为每一种操作封装成一个函数。

先说顺序表初始化：

顺序表初始化

顺序表存放数据一定是从第一个位置开始放。

后面存放的数据不允许中间有位置空着，必须是相继存放的形式。数据的值不允许是连续的，比如1后面不一定是2，也可以是3或者其他任何数，但是放的位置必须是相继连续的。

后面的数据也可以是放在第一个位置，然后将第一个位置上的数据挤到后面的位置。

比如以下两种存放方式都是可以的。

如何表示顺序表

struct SequenceList

{

int data[SIZE]; //顺序表起始地址和容量

int length; //顺序表长度

};

typedef struct SequenceList seqList;

注意：容量和长度是不一样的，比如现在这个顺序表：

它的容量是6，目前长度是1。

现在我们开始在Linux终端写代码演示一下：

先创建一个目录datastruct；

然后再在datastruct目录下创建一个sequencelist的目录；

再在sequencelist目录下创建文件，我们在数据结构这部分写代码的时候一般分为三个文件，一个是头文件（.h），两个源文件（.c）

三个文件的作用：

我们先来看看头文件应该怎么写：

我们写头文件的第一步最好先写好这个框架

#ifndef _LIST_H #define _LIST_H #endif这三行代码的作用是防止头文件被重复定义。

#ifndef _LIST_H #define _LIST_H #endif这三行代码为什么能防止重复定义呢？

首先重复定义就是比如你某天在主文件中写代码的时候重复定义了#include <stdio.h>

那编译的时候会不会报错呢？

编译不会报错。为什么呢？

因为我们所包含的stdio.h这头文件中就有这三行代码

我们复习Linux C语言的时候讲过编译的过程，在预处理环节，头文件会被展开，展开后就会遇到这句话#ifndef _STDIO_H，这时编译器就会看一下，如果没有定义这个STDIO.H，那么就执行 # define _STDIO_H，把这个宏定义一下，这时STDIO.H就是被定义过了。

等到第二次你又去包含这个头文件的时候，预处理的时候有会展开这个头文件，又遇到#ifndef _STDIO_H，这时编译器会看一下，知道STDIO.H就是被定义过了，不满足条件了，则编译器会跳过# define _STDIO_H及其后面的代码，直接到#endif。

包含头文件的写法有两种：一种是用尖括号包含的头文件，一种是双引号包含的头文件。

这两种有什么区别呢？

尖括号包含的头文件默认去系统指定的目录下找头文件；

双引号包含的头文件默认在当前目录下找头文件，如果找不到的话也会去系统指定的目录下去找这个头文件。

我们继续完成我们本节的头文件list.h，声明结构体及其他。

图片更正：#define SUCCESS 1000

然后我们在主文件main.c中创建一个顺序表，我们是用结构体来表示顺序表列表的，创建顺序表即定义一个结构体变量。

list.c用来实现函数。

同时编译main.c 和list.c

这样顺序表初始化就成功了

顺序表插入

比如说我们现在有这样一个顺序表，还没有存满数据，还能够插入数据

以上这个顺序表我们可以从第一个位置插入，在第二个位置和第三个位置插入也行，这样就会把原本这个位置上的数据挤到后面的位置。我们也可以在第四个位置插入，我们将这个中插入方式叫做尾插法。但是，我们不能直接在第五个位置及其后面的位置插入，这样的话就会空出第四个位置，这样就不是所谓的顺序表了。

插入的方法就是比如说想要插入到第二个位置，那么就将第二个位置上的数及其后面的数都往后挪一个位置，然后将要插入的数插入到空出来的第二个位置。挪位置时的循环操作次数是顺序表长度-要插入的位置+1。

代码演示：

List.c

List.h

在头文件中声明一下这个函数

Main.c

运行结果：

如果插入11那最后一个就会报错，因为我们设置的顺序表容量总共是SIZE =10

顺序表遍历操作

虽然我们看到插入成功了，但是数据到底有没有插入到顺序表里面，我们是看不到的，接下来我们就来遍历一下这个顺序表。

代码演示：

List.c

List.h

在头文件中声明一下这个函数

Main.c

运行结果：

顺序表前驱和后继

我们接下来演示一下如何获得一个顺序表的前驱和后继

代码演示：

List.c

在List.h里面声明一下这两个函数

main.c

运行结果：

顺序表查找操作

查找有两种情况：一种是给定位置，返回该位置的元素是几；另一种是定位，给定一个元素，查找这个元素的位置。

代码演示：

List.c

在List.h里面声明一下这两个函数

Main.c

运行结果：

顺序表删除操作

比如这样一个顺序表，我们想要将第二个位置上的数据删除掉，那么这个位置将会变成空的，根据顺序表的特点，我们必须要将这个位置后面的数据向前挪，补上这个空缺。挪动的次数是长度-被删除的位置。

删除操作最重要的是判断删除的位置是否合法。比如说想要删除第四个位置肯定是不行的，因为这个顺序表中的第四个位置是空的。因此我们要判断一下位置是否合法。

代码演示：

List.c

在List.h中声明一下这个函数

Main.c

运行结果：

求顺序表的长度和判断顺序表是否为空这个比较简单就不写代码了。求顺序表的长度，我们只要写一个return l->length;因为我们length本身就是结构体里面的成员, return l->length如果为零，说明顺序表位空。

顺序表清空销毁

顺序表清空，我们只要将顺序表的长度变成零即可。到时候我们要插入数据的话就必然是从顺序表的第一个位置开始插入。

代码演示：

List.c

在List.h里面声明这个函数

Main.c

运行结果：

顺序表清空成功了，如何来验证呢？我们遍历一下就可以了，在主函数中调用遍历函数。

代码演示：

运行结果：

没有遍历出元素，说明的确是清空了。

顺序表销毁操作

接下来是销毁操作

我们将malloc申请的data指向的那块空间即顺序表给释放掉就是销毁操作。这时data会变成野指针，我们要将data置为空指针。

代码演示：

List.c

在list.h里面声明一下这个函数

Main.c

运行结果：

销毁成功后按理是不能再插入数据了，我们调用插入数据的函数验证一下

代码演示：

运行结果：

插入失败，说明data指向的那块内存的确被销毁了。

完整代码

List.c

//实现所有的函数
#include "list.h"
#include <stdlib.h>//malloc的头文件
#include <stdio.h>//printf的头文件

//顺序表的初始化操作,定义函数
int init_list(List *l)//把结构体的地址传过来
{
	if(NULL==l)//入参判断，防止传过来空指针
	{
		return FAILURE;
	}

	l->data=(int*)malloc(sizeof(int)*SIZE);
	if(NULL==l->data)
	{
		return FAILURE;
	}

	l->length=0;

	return SUCCESS;
}

//顺序表的插入操作
int insert_list(List *l,int p,int num)
{
	//判断是否空指针
	if(NULL==l||NULL==l->data)
	{
		return FAILURE;
	}
	//判断顺序表是否满
	if(l->length>=SIZE)
	{
		return FAILURE;
	}
	//判断位置是否合法
	if(p>l->length+1)
	{
		return FAILURE;
	}
	//挪位置
	int i;
	for(i=0;i<l->length-p+1;i++)
	{
		l->data[l->length-i]=l->data[l->length-1-i];
	}
	//插入
	l->data[p-1]=num;//p是位置，p-1是下标
	l->length++;//插入数据后，长度加1
	return SUCCESS;
}

//顺序表的遍历操作
void traverse_list(List l)
{
	int i;
	for(i=0;i<l.length;i++)
	{
		printf("%d ",l.data[i]);
	}
	printf("\n");
}

//顺序表获取前驱操作
int get_prior_list(List l,int num,int *r)
{
	int i;
	//将num和顺序表中的数进行匹配,看看顺序表中有没有这个数
	for(i=1;i<l.length;i++)//第一个位置上的数没有前驱，所以i从1开始
	{
		if(l.data[i]==num)
		{
			*r=l.data[i-1];
			return SUCCESS;
		}
	}
	return FAILURE;
}

//顺序表获取后继操作
int get_next_list(List l,int num, int*r)
{
	int i;
	for(i=0;i<l.length-1;i++)//最后一个位置上的数没有后继，所以循环次数l.length-1
	{
		if(l.data[i]==num)
		{
			*r=l.data[i+1];
			return SUCCESS;
		}
	}
	return FAILURE;
}

//顺序表的查找操作
int find_list(List l,int p, int *n)
{
	//先判断位置是否合法
	if(p<=0||p>l.length)
	{
		return FAILURE;
	}
	*n=l.data[p-1];//p-1是下标
	return SUCCESS;
}

//顺序表的定位操作
int locate_list(List l, int num, int *p)
{
	int i;
	for(i=0;i<l.length;i++)
	{
		if(num==l.data[i])
		{
			*p=i+1;//记录位置
			return SUCCESS;
		}
	}
	return FAILURE;
}

//顺序表的删除操作
int delete_list(List *l,int p,int *n)
{
	//入参判断
	if(NULL==l||NULL==n)//两个指针不能为空
	{
		return FAILURE;
	}
	//判断删除的位置是否合法
	if(p>l->length||p<=0)//删除的位置超出了范围或者是个空表则不能删除
	{
		return FAILURE;
	}

	*n=l->data[p-1];//要删除的那个元素

	//挪位置，即用后一个元素覆盖要删除的元素，后面的也依次覆盖
	int i;
	for(i=0;i<l->length-p;i++)
	{
		l->data[p-1+i]=l->data[p+i];
	}
	//这种覆盖的方式，最后一个元素并没有东西覆盖它，但是留着也没有影响，我们只要长度减1就行，下次要插入元素的话自然就能将它覆盖了
	l->length--;
	return SUCCESS;
}

//顺序表的清空操作
int clear_list(List *l)
{
	//入参判断
	if(NULL==l)
	{
		return FAILURE;
	}

	l->length=0;//清空：直接让长度变成0

	return SUCCESS;

}

//顺序表的销毁操作
int destroy_list(List *l)
{
	//入参判断
	if(NULL==l)
	{
		return FAILURE;
	}

	free(l->data);
	l->data=NULL;
	return SUCCESS;
}

List.h

#ifndef _LIST_H
#define _LIST_H

#define SIZE  10  //宏定义顺序表的容量为10
#define SUCCESS 1000
#define FAILURE 1001

//结构体声明
typedef struct Sequencelist
{
	int *data;//顺序表的起始地址
	int length;//顺序表长度

}List;//将struct Sequencelist{};重命名为List

//声明函数
int init_list(List *l);
int insert_list(List *l,int p,int num);
void traverse_list(List l);
int get_prior_list(List l,int num,int *r);
int get_next_list(List l,int num, int*r);
int find_list(List l,int p, int *n);
int locate_list(List l, int num, int *p);
int delete_list(List *l,int p,int *n);
int clear_list(List *l);



#endif

Main.c

#include <stdio.h>//尖括号包含的头文件默认去系统指定的目录下找头文件
#include "list.h"//双引号包含的头文件默认在当前目录下找头文件
#include <time.h>//time的头文件
#include <stdlib.h>//rand和srand的头文件

int main()
{
	//创建顺序表（定义一个结构体变量）
	List seqList;

	//初始化顺序表,调用函数
	int ret=init_list(&seqList);//如果要修改实参的值，必须要取地址
	if(SUCCESS==ret)
	{
		printf("顺序表初始化成功\n");
	}
	else
	{
		printf("顺序表初始化失败\n");
	}

	//顺序表的插入
	int i,num;
	srand(time(NULL));//设置种子，给srand()函数传的数每次不一样的话，则每次运行的结果就会不一样，因此我们用time()作为参数
	for(i=0;i<11;i++)//插入i个数
	{

	 	num=rand()%20;//产生随机数，如果种子一样，则产生的数字是一样，否则每次产生的数不一样
		//任何数%20都得到一个0～19范围内的数
		ret=insert_list(&seqList,i+1,num);//i是顺序表中data的元素的下标,i+1是位置,num是要插入的数
		if(SUCCESS==ret)
		{
			printf("插入%d成功\n",num);//插入随机数成功
		}
		else
		{
			printf("插入%d失败\n",num);
		}
	}

	//遍历顺序表，类似遍历数组
	traverse_list(seqList);

	//获得顺序表前驱
	num=rand()%20;//获得一个随机数的前驱
	int result;//保存结果
	ret=get_prior_list(seqList,num,&result);//因为要找到前驱并赋值给result,所以要取地址
	if(SUCCESS==ret)
	{
		printf("%d的前驱是%d\n",num,result);
	}
	else
	{
		printf("%d不存在前驱\n",num);
	}

	//获取后继元素
	ret=get_next_list(seqList, num, &result);
	if(SUCCESS==ret)
	{
		printf("%d的后继是%d\n",num,result);
	}
	else
	{
		printf("%d不存在后继\n",num);
	}

	//查找操作
	int p=rand()%15;//随机产成一个位置，这个位置在0～14范围内，比顺序表的容量大，有可能查找是失败的
	ret=find_list(seqList,p,&num);//num用来保存查找的那个元素
	if(SUCCESS==ret)
	{
		printf("第%d个元素是%d\n",p,num);
	}
	else
	{
		printf("第%d不存在\n",p);
	}
	//定位操作
	num=rand()%20;//随机给定一个元素，查找它的位置是几
	ret=locate_list(seqList, num, &p);
	if(SUCCESS==ret)
	{
		printf("元素%d的位置是%d\n",num,p);
	}
	else
	{
		printf("元素%d不存在\n",num);
	}

	//删除元素
	for(i=0;i<5;i++)//删除5个元素
	{
		p=rand()%10;//随机删除一个位置
		ret=delete_list(&seqList,p,&num);//因为长度要改变，所以seqList要取地址，被删除掉的元素保存在num里面
		if(SUCCESS==ret)
		{
			printf("删除第%d个元素%d成功\n",p,num);
		}
		else
		{
			printf("删除第%d个元素失败\n",p);
		}
	}

	//清空操作
	ret=clear_list(&seqList);
	if(SUCCESS==ret)
	{
		printf("顺序表清空成功\n");		
	}
	else
	{
		printf("顺序表清空失败\n");
	}

	//遍历顺序表，类似遍历数组
	traverse_list(seqList);

	//销毁操作
	ret=destroy_list(&seqList);//因为我们要将结构体中的data变为空指针，所以要取地址
	if(SUCCESS==ret)
	{
		printf("顺序表销毁成功\n");		
	}
	else
	{
		printf("顺序表销毁失败\n");
	}

	//顺序表的插入
	srand(time(NULL));//设置种子，给srand()函数传的数每次不一样的话，则每次运行的结果就会不一样，因此我们用time()作为参数
	for(i=0;i<11;i++)//插入i个数
	{

	 	num=rand()%20;//产生随机数，如果种子一样，则产生的数字是一样，否则每次产生的数不一样
		//任何数%20都得到一个0～19范围内的数
		ret=insert_list(&seqList,i+1,num);//i是顺序表中data的元素的下标,i+1是位置,num是要插入的数
		if(SUCCESS==ret)
		{
			printf("插入%d成功\n",num);//插入随机数成功
		}
		else
		{
			printf("插入%d失败\n",num);
		}
	}
	return 0;
}

顺序表优缺点（面试可能会考）

我们在实际的开发过程中涉及到的数据量是比较大的，数组可能无法解决问题，因为我们可以借助顺序表来解决问题。

而且顺序表相比较于链表有一个好处就是访问数据比较简单，我们直接在写元素的下标就行，比如我们要访问第9个元素，我们只需要：l->data[8]这样就能访问。

但是顺序表在头部插入的效率低，因为插入一个数据，之后的数据都得往后挪；而且容量有限，一开始我们用malloc申请了一块空间后，不够用了的话需要调用realloc()来扩展内存。

实际上，在开发的过程中我们也很少使用顺序表，我们用的比较多的是链表，因为链表不需要申请一块连续的内存。

下回我们就来具体学习链表了，敬请关注！

QQ交流群：963138186

本篇就到这里，下篇继续！欢迎点击下方订阅本专栏↓↓↓

Vera工程师养成记

关注

24
点赞
踩
13

收藏

觉得还不错? 一键收藏
打赏
0
评论
嵌入式全栈开发学习笔记---数据结构（顺序表）

顺序表应该支持以下操作：初始化操作，建立一个空的顺序表InitList(*L); 判断顺序表是否为空 ListEmpty(L); 清空顺序表ClearList(*L);获取第i个位置的元素，存放在e中GetElem(L, i, *e); 查找于e相等的元素，返回元素的位置LocateElem(L, e); 在第i个位置插入元素eListInsert(*L, i, e); 删除第i个位置的元素，保存在e中ListDel(*L, i, *e); 获
复制链接

扫一扫