顺序表，链表的代码实现与比较

最新推荐文章于 2023-07-18 11:20:33 发布
最新推荐文章于 2023-07-18 11:20:33 发布
阅读量220 收藏 3
点赞数
文章标签： 链表 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73592835/article/details/128487175
版权

目录

一、顺序表与链表简介

概念与结构

二、代码实现

1.顺序表

2.链表

2.1 无头单向非循环链表

2.2 带头双向循环链表

三、顺序表与链表的比较

1.顺序表

2.链表

一、顺序表与链表简介

概念与结构

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

物理结构如下

 顺序表一般可以分为：
1. 静态顺序表：使用定长数组存储元素。

#define N 100
typedef int ElemType;
typedef struct SeqList{
	ElemType data[N];
	int size;
	int capacity;
}SL;

2.动态顺序表：使用动态开辟的数组存储。

typedef int ElemType;
typedef struct SeqList{
	ElemType *data;
	int size;
	int capacity;
}SL;

链表概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

物理结构如下：

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向或双向

 

2. 带头或不带头

 

3. 循环或非循环

 

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。 

带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了

二、代码实现

1.顺序表

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

.h文件

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int ElemType;
typedef struct SeqList{
	ElemType *data;
	int size;
	int capacity;
}SL;
void SLInit(SL* p); //顺序表初始化
void SLPushBack(SL *p, ElemType x); //尾插
void SLPushFront(SL *p, ElemType x); //头插
void SLPopBack(SL *p);  //尾删
void SLPopFront(SL *p); //头删 
int SLFind(SL *p,ElemType x);   //查找并返回下标
void SLInsert(SL *p, int pos, ElemType x);    //在指定位置插入
void SLErase(SL *p, int pos);   //删除pos位置数据
void SLPrintf(SL *p);  //打印
int SLSize(SL *p);  //返回元素个数
bool SLEmpty(SL *p); //判空
void SLDestroy(SL *p);  //销毁

.c函数实现文件

#include"SeqList.h"
void SLInit(SL* p){      //顺序表初始化
	p->data = (ElemType *)malloc(sizeof(ElemType)* 10);
	if (p->data == NULL){
		printf("malloc fail\n");
		exit(-1);
	}
	p->size = 0;
	p->capacity = 10;
}
void SLCheckCapacity(SL *p){   //判断是否满了
	if (p->size == p->capacity){         
		ElemType *new = realloc(p->data, sizeof(ElemType)*(p->capacity + 5));
		if (new == NULL){
			printf("realloc fail");
			exit(-1);
		}
		p->data = new;
		p->capacity += 5;
	}
}
void SLPushBack(SL *p, ElemType x){      //尾插
	SLCheckCapacity(p);
	p->data[p->size] = x;
	p->size++;
}
void SLPushFront(SL *p, ElemType x){      //头插
	SLCheckCapacity(p);
	for (int i = p->size; i > 0; i--){   //数据后移
		p->data[i] = p->data[i - 1];
	}
	p->data[0] = x;
	p->size++;
}
void SLPopBack(SL *p){   //尾删
	if (p->size == 0){
		printf("该表暂无内容，无法删除\n");
		return;
	}
	p->size--;
}
void SLPopFront(SL *p){   //头删
	if (p->size == 0){
		printf("该表暂无内容，无法删除\n");
		return;
	}
	for (int i = 0; i < p->size-1; i++){     //数据前移
		p->data[i] = p->data[i + 1];
	}
	p->size--;
}
int SLFind(SL *p,ElemType x){  //查找并返回下标
	int i;
	for ( i = 0; i < p->size; i++){
		if (x == p->data[i]){
			return i;
		}
	}
	printf("没找到该元素\n");
}
void SLInsert(SL *p, int pos, ElemType x){   //在指定位置插入
	SLCheckCapacity(p);    //先判断是否满了
	if (pos<0 || pos>p->size+1){   //判断pos的值是否合法
		printf("请在合理的范围插入\n");
		return;
	}
	for (int i =p->size; i >pos-1; i--){  //数据后移
		p->data[i] = p->data[i-1];
	}
	p->data[pos-1] = x;
	p->size++;
}
void SLErase(SL *p, int pos){   //删除pos位置数据
	if (p->size == 0){
		printf("该表暂无内容，无法删除\n");
		return;
	}
	if (pos<0 || pos>p->size){   //判断pos的值是否合法
		printf("请在合理的范围插入\n");
		return;
	}
	for (int i =pos-1; i<p->size-1; i++){   //数据前移
		p->data[i] = p->data[i+1];
	}
	p->size--;
}
int SLSize(SL *p){   //返回表中元素个数
	return p->size;
}
bool SLEmpty(SL *p){ //判空
	return p->size == 0;
}
void SLDestroy(SL *p){  //销毁
	free(p->data);
	p->data = NULL;
	p->size = p->capacity = 0;
}
void SLPrintf(SL *p){    //打印
	for (int i = 0; i < p->size; i++){
		printf("%d ", p->data[i]);
	}
	printf("\n");
}

2.链表

2.1 无头单向非循环链表

.h头文件

#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct SListNode{
	ElemType data;
	struct SListNode *next;
}SN;
//void SListInit(SN **p);  //初始化
void SListPushBack(SN **p, ElemType x); //尾插
void SListPushFront(SN **p, ElemType x); //头插
void SListPopBack(SN **p); //尾删
void SListPopFront(SN **p); //头删
void SListPrintf(SN **p);  //打印链表
SN *SListFind(SN **p,ElemType x);  //查找
void SListInsert(SN **p, SN *pos, ElemType x); //在pos位置前插入一个结点
void SListInsertAfter(SN **p, SN *pos, ElemType x); //在pos位置后面插入一个结点
void SListErase(SN **p, SN *pos); //删除pos位置结点
void SListDestroy(SN **p); //销毁链表

.c各个函数实现文件

#include"SList.h" 
SN* newnode(ElemType x){     //生成新结点函数
	SN *new = (SN *)malloc(sizeof(SN));
	new->data = x;
	new->next = NULL;
	return new;
}
void SListPrintf(SN **p){   //打印函数
	SN *head = *p;
	while (head != NULL){
		printf("%d ", head->data);
		head = head->next;
	}
	printf("\n");
}
void SListPushBack(SN **p, ElemType x){  //尾插
	SN *head = *p;
	if (*p == NULL){   //当链表为空时，构造第一个结点
		*p = newnode(x);
		return;
	}
	while (head->next != NULL){  //找到尾结点
		head = head->next;
	}
	head->next = newnode(x);   
}
void SListPushFront(SN **p, ElemType x){   //头插
	SN *head = *p;  //将原本头指针指向的结点保存起来
	*p = newnode(x);
	(*p)->next = head;
}
void SListPopBack(SN **p){   //尾删  当链表只有一个结点，tail为空，会导致越界访问
	if (*p == NULL){
		printf("该链表为空\n");
		return;
	}
	if ((*p)->next == NULL){   //当只有一个结点时
		free(*p);
		*p = NULL;
		return;
	}
	SN *head = *p;         //有两个及两个以上结点时
	SN *tail = NULL;     //用来储存倒数第二个结点
	while (head->next != NULL){
		tail = head;
		head = head->next;
	}
	tail->next = NULL;
	free(head);
	head = NULL;
}
void SListPopFront(SN **p){  //头删
	if (*p == NULL){                //当链表为空时
		printf("该链表为空\n");
		return;
	}
	SN *next = (*p)->next;
	free(*p);
	*p= next;
}
SN *SListFind(SN **p, ElemType x){  //查找
	SN *head = *p;
	while (head != NULL){
		if (head->data == x){
			return head;
		}
		head = head->next;
	}
	return NULL;
}
void SListInsert(SN **p, SN *pos, ElemType x){  //在pos位置前插入
	if (pos == *p){
		SListPushFront(p, x);       //当只有一个
	}
	else{
		SN *head = *p;
		while (head->next != pos){
			head = head->next;
		}
		SN *new = newnode(x);
		head->next = new;
		new->next = pos;
	}
}
void SListInsertAfter(SN **p, SN *pos, ElemType x){    //在pos位置后面插入一个结点
	SN *new = newnode(x);
	new->next = pos->next;
	pos->next = new;
}
void SListErase(SN **p, SN *pos){    //删除pos位置结点
	if (*p == pos){
		SListPopFront(p);
	}
	else{
		SN *head = *p;
		while (head->next != pos){
			head = head->next;
		}
		head->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
void SListDestroy(SN **p){   //销毁链表
	SN* head = *p;
	while (head != NULL){
		SN *next = head->next;
		free(head);
		head = next;
	}
	*p = NULL;
}

2.2 带头双向循环链表

.h头文件

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int ElemType;
typedef struct ListNode{
	ElemType data;
	struct ListNode*next;
	struct ListNode*prev;
}LN;
void LNInit(LN *p); //初始化
void LNPrintf(LN *p); //打印
void LNPushBack(LN *p, ElemType x);  //后插
void LNPushFront(LN *p, ElemType x);  //头插
void LNPopBack(LN *p); //尾删
void LNPopFront(LN *p); //头删
LN *LNFind(LN *p,ElemType x); //查找
void LNInsert(LN *pos, ElemType x);  //在pos前插入x
void LNErase(LN *pos);  //删除pos结点
void LNDestroy(LN *p);  //销毁链表

.c函数实现文件

#include"DList.h"
LN *newnode(ElemType x){    //创造结点
	LN *new = (LN *)malloc(sizeof(LN));
	new->data = x;
	new->next = new->prev = NULL;
	return new;
}
void LNInit(LN **p){  //初始化
	LN *phead = (LN *)malloc(sizeof(LN));   //创造一个头结点
	phead->next = phead->prev = phead;
	*p = phead;
}
void LNPrintf(LN *p){  //打印
	if (p->next == p){
		printf("该链表为空\n");
		return;
	}
	LN *cur = p->next;
	while (cur != p){
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
void LNPushBack(LN *p, ElemType x){  //后插
	LN *new = newnode(x);
	LN *tail = p->prev;   //尾结点
	tail->next = new;
	new->prev = tail;
	new->next = p;
	p->prev = new;
	//LNInsert(p, x);
}
void LNPushFront(LN *p, ElemType x){  //前插
	LN *new = newnode(x);
	LN *frist = p->next;  //先保存第一个结点的地址
	p->next = new;
	new->next = frist;
	new->prev = p;
	frist->prev = new;
	//LNInsert(p->next, x);
}
void LNPopBack(LN *p){   //尾删
	assert(p->next != p);  //链表空了不能删了
	LN *tail = p->prev; //尾结点
	LN *last = tail->prev; //倒数第二个结点
	last->next = p;
	p->prev = last;
	free(tail);
	tail = NULL;
	LNErase(p->prev);
}
void LNPopFront(LN *p){   //头删
	assert(p->next != p); 
	LN *frist = p->next;
	p->next = frist->next;
	frist->next->prev = p;
	free(frist);
	frist = NULL;
	//LNErase(p->next);
}
LN* LNFind(LN *p,ElemType x){  //查找
	LN *cur = p->next;
	while (cur != p){
		if (cur->data == x){
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
void LNInsert(LN *pos, ElemType x){  //在pos前插入
	LN *new = newnode(x);
	LN *posprev = pos->prev;  //pos前结点
	new->next = pos;
	new->prev = posprev;
	posprev->next = new;
	pos->prev = new;
}
void LNErase(LN *pos){   //删除pos结点
	LN *posprev = pos->prev;
	LN *posnext = pos->next;
	posprev->next = posnext;
	posnext->prev = posprev;
	free(pos);
}
void LNDestroy(LN **p){   //销毁
	LN *cur = (*p)->next;
	while (cur != (*p)){
		LN *next = cur->next;
		free(cur);
		cur = next;
	}
	free(*p);
	*p = NULL;
}

三、顺序表与链表的比较

1.顺序表

优点：

1. 用下标访问，支持随机访问，需要随机访问结构支持的算法可以很好的适用

2. CPU高速缓存命中率更高

缺点：

1.头部中部插入需要大量挪动数据，效率低

2.连续的物理空间，满了需要增容，会造成空间浪费

2.链表

以双向带头循环链表为例.

优点：

1.任意位置插入删除效率高

2.按需申请释放空间

缺点:

1.不支持随机访问（用下标访问），意味着一些算法比如说二分查找无法使用

2.一个结点存储一个值，还要存储下一个节点指针，有一定消耗

3.CPU高速缓存命中率低

 

叫我小可爱就好
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
顺序表和链表之间的对比(含代码)
weixin_45122262的博客
04-08 278
顺序表 数据保存在连续的内存空间上 支持随机访问 擅长尾插和尾删(O(1),如若触发扩容逻辑 - > O(N) 不擅长中间位置插入/删除 O(N) ,效率低 public class SeqList { private int[] datas = new int[100]; //一个叫datas的内存有 100 的空间 private int size = 0; //把...
java单向链表代码实现
最新发布
12-25
以上代码实现了一个简单的单向链表，包括插入、删除、遍历和获取链表长度的功能。在实际的软件开发中，链表常被用作基础数据结构，特别是在需要频繁进行插入和删除操作而对顺序访问性能要求不高的场景。例如，解析...
顺序表和链表对比
qq_43514458的博客
11-02 520
1、底层结构上 顺序表底层结构是一段连续的空间(也可以这么说顺序表底层空间是逻辑上和物理上都是连续的） 链表底层结构是动态的创建不连续的空间(链表底层是逻辑上连续，物理上不连续) 2、随机访问 顺序表支持随机访问，访问某个元素效率为o（1） 链表不支持随机访问，访问某个元素的效率为o(n) 3、插入和删除效率 顺序表的插入删除效率低，需要搬移元素，时间复杂度为o(n)，并且再插入的时候还有可能需要...
【数据结构】顺序表、单链表的 比较+总结
It’s All Uphill From Here
09-17 1495
（优缺点文字部分转自： http://blog.csdn.net/zhang_minli/article/details/50489996）顺序表和链表de优缺点顺序表的优点方法简单，各种高级语言中都有数组，容易实现。 不用为表示结点间的逻辑关系而增加额外的存储开销（链表要增加额外的指针域）。 顺序表具有按元素序号随机访问的特点。缺点 在顺序表中做插入删除操作时，平均移动大约表中一般的元素，因
数据结构与算法——顺序表和链表的优缺点（区别、特点）详解
Itmastergo的博客
07-18 3413
顺序表和链表是常见的两种数据结构，用于组织和存储数据。它们在实际应用中各有优缺点，下面详细讲解一下它们的区别、特点以及各自的优缺点。
数据结构顺序表和4个链表的代码
09-13
本篇将深入探讨这两种数据结构及其在C++语言中的实现，通过分析提供的代码文件（dlink.cpp、sqlist.cpp、slink.cpp、cdlink.cpp、cslink.cpp），我们可以学习到不同类型的链表以及一个顺序表的实现方式。 首先，...
顺序链表C++实现
09-06
在C++中实现顺序链表，我们需要理解基本的C++语法，包括类、构造函数、析构函数、指针操作以及动态内存分配。 首先，创建一个表示链表节点的结构体或类是必要的。这个类通常包含两个成员：一个用于存储数据，另一个...
C语言实现顺序表代码.rar
04-02
本资源"**C语言实现顺序表代码**"提供了一种用C语言编写的顺序表实现，这对于学习数据结构和算法的初学者来说是一份宝贵的参考资料。下面将详细讨论C语言实现顺序表涉及的知识点。 1. **数组**：在C语言中，数组是...
C语言顺序表_单链表_双链表代码.zip
03-30
本压缩包"**C语言顺序表_单链表_双链表代码.zip**"提供了C语言实现的三种基本数据结构——顺序表、单链表和双链表的源代码，这些代码适用于初学者学习和实践。以下将详细介绍这三种数据结构及其应用。 **1. 顺序表*...
线性表之顺序表与单链表的区别及优缺点
热门推荐
ljx_5489464的博客
03-23 3万+
这里比较的是基于C语言实现的顺序表与单链表，与其他语言的实现可能会有差异，但我相信语言是相通的，它们的实现机制应该也差不多。 1、What 什么是顺序表和单链表 ①顺序表： 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。只要确定了起始位置，表中任一元素的地址都通过下列公式得到：LOC（ai）=LOC（a1）+（i-1）*L 　1≤i≤
C语言实现的顺序链表代码
bsr1983的专栏
03-04 334
      数据结构上机考试练习代码，置于此以备后用！        #include&lt;stdio.h&gt; #define ListSize 100 //定义顺序表存放的数据类型 typedef int DataType; //定义顺序表的结构 typedef struct{ //用于存放元素的数组 DataType data[ListSize]; ...
#数据结构##算法##代码#顺序链表
kkkkkkc1的博客
05-21 140
工程由三个文件组成。 list.h #ifndef __LIST_H__ #define __LIST_H__ struct list; /* 构造一个空的线性表，成功返回其地址；失败返回NULL */ struct list *list_init(); /* 释放线性表list */ void list_free(struct list *list); /* 返回线性表的数据元素个数 */ int list_count(const struct list *list);
顺序表和链表的代码实现
WXGQSCR的博客
10-06 304
线性表的各类基础功能的代码实行
数据结构——C语言实现 顺序表和链表代码
ZhangJiawen的博客
10-25 2729
今天敲了一下数据结构中顺序表的代码，发现C语言好久不用真的忘得差不多了。代码都是可以直接运行的（我的运行环境是Dev）。如果有写错的地方，欢迎大家留言一起讨论。 对这一部分概念的介绍可以参考这篇博客：数据结构中的顺序表 下来就直接看代码吧 #include<stdio.h> #define MAXSIZE 100 typedef struct{ int elem[MAXSIZE]; int length; }SeqList; //初始化 void Init_SeqList(SeqLis
顺序表和单链表的区别 以及顺序表和单链表的代码
shadow___h的博客
11-13 1792
链表中顺序表和单链表的区别 存储分配方式的不同 顺序表 一段连续的存储单元一次存储线性表的数据元素 顺序表代码的实现，其本质就是一个数组和最大容量（也就是数组的长度）以及现有的长度。当我们每存储进一个数据的时候，他的现有长度增加，当增加到最大的容量的时候，我们就需要给顺序表扩容。 我们很难把顺序表的空间容量全部利用。 与单链表相比它无须为表中元素之间的逻辑关系增加额外的存储空间 单链表 1. 采用的链式存储结构，用一组任意的存储单元存放线性表 2. 就是我们添加了一个引用，这个引用中存放了下
c语言实现顺序性链表
flying_coding的博客
09-05 1171
注意事项： 改变元素个数时更新lenth 进行增添元素时检查表是否满 插入、删除时检查位置是否合法 能用取地址符号就尽量用，代码简洁 库函数realloc的用法 原理分析： SqList结构体变量只需要提供一个指针的头部，剩下的操作都由函数完成 #include<stdio.h> #include<stdlib.h> #include<memory.h> #...
用c语言实现顺序表和链表,利用C++简单实现顺序表和单链表的示例代码
weixin_39950824的博客
05-21 378
本文主要给大家介绍了关于C++实现顺序表和单链表的相关内容，分享出来供大家参考学习，话不多说，来一起看看详细的介绍：一、顺序表示例代码：#include #include using namespace std;typedef int Datatype;class SeqList{public:SeqList():_array(NULL),_size(0),_capacity(0){}SeqLis...
顺序表与链表的c++代码对比
quency的博客
02-02 325
顺序表与单链表对比（以c++代码为例） 目录顺序表与单链表对比（以c++代码为例）结构表示形式创建方式初始化方式判断为空表求长度输出方式随机访问元素的值判断元素是否在表中插入元素删除元素销毁表 结构表示形式 顺序表类似数组，也可由一个结构体表示，该结构体含有一个数组和一个记录数组有效元素长度的变量。 typedef struct { int number[40]; int length; }SqList; //typedef表示别名 用一个结构体作为单链表的一个节点，该结构体含有一个
顺序链表的实现和链表查询的实现
Future_One的专栏
03-25 2616
顺序链表的创建和顺序链表的查询
新教材_zyj_chapter+2+New1
08-04
本资源主要探讨的是计算机科学中的线性表及其基本运算，包括线性表的两种主要表示方法：顺序表和链表。章节开始首先定义了线性表，它是一个有限序列，由 n (n  0) 个数据元素组成，每个元素用 ki 表示，表的长度为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值