【数据结构】一、链表

最新推荐文章于 2023-10-12 00:10:42 发布
最新推荐文章于 2023-10-12 00:10:42 发布
阅读量271 收藏
点赞数
分类专栏： # 基本数据结构（更新中…） 文章标签： 数据结构 链表 单链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Martin0316/article/details/117487953
版权

作者：MiTu_-_

  基本数据结构

  一、链表
  二、栈
  三、队列
  四、待续…

一、链表

1.顺序表

是一种用动态分配的一维数组的线性顺序表，可以随机存储。

//名称：SqList()
//功能：线性顺序表
//说明：由于线性表的长度可变，且最大存储空间随问题不同而不同，所以用动态分配的一维数组 

#include <stdio.h>
#include <stdlib.h>

#define OK						1
#define ERROR					0
#define LIST_SIZE				100
#define LIST_INCREMENT_SIZE		20

typedef int Status;

//链表定义
typedef int LT;		//ListElemType
typedef struct {
	LT * data;			//基址 
	int length;			//当前线性表长度 
	int listsize;		//当前分配的存储容量 
} SqList;

//链表操作
Status Init_SqList(SqList * L);
Status Insert_SqList(SqList * L, int i, LT e);
Status Delete_SqList(SqList * L, int i, LT * e);
Status Traverse_SqList(SqList L);
int Locate_data(SqList L, LT e);

int main(void)
{
	int pos;
	LT e;
	SqList L;
	Init_SqList(&L);
	Insert_SqList(&L, 1, 1);
	Insert_SqList(&L, 2, 10);
//	Delete_SqList(&L, 2, &e);
	Traverse_SqList(L);
	pos = Locate_data(L, 10);

	return 0;
} 

Status Init_SqList(SqList * L)
{
	int i, n; 
	L->data = (LT *)malloc(LIST_SIZE * sizeof(LT));
	if (!L->data)
		return ERROR;
	printf("请输入链表长度：");
	scanf("%d", &n);
	printf("请输入%d个链表元素：", n);
	for (i = 0; i < n; ++i)
		scanf("%d", &L->data[i]);
	L->length = n;					//链表长度为n
	L->listsize = LIST_SIZE;
	
	return OK;
}

Status Insert_SqList(SqList * L, int n, LT e)
{
	//在线性顺序表L中第n个位置之前插入元素e，位置为 1 ~ L->length  
	LT * newbase;						//以备增加空间 
	int i;
	if (n < 1 || n > L->length + 1)
		return ERROR;
	if (L->length >= L->listsize)		//当前存储空间已满，增加分配 
	{
		newbase = (LT *)realloc(L->data, (L->listsize + LIST_INCREMENT_SIZE) * sizeof(LT));
		if (!newbase)
			return ERROR;
		L->data = newbase;
		L->listsize += LIST_INCREMENT_SIZE; 
	}
	for (i = L->length - 1; i >= n - 1; --i)	//插入位置元素之后的元素后移 
		L->data[i + 1] = L->data[i];
	L->data[n - 1] = e;
	++L->length;
	
	return OK;	
}

Status Delete_SqList(SqList * L, int n, LT * e)
{
	//在线性顺序表L中删除第n个元素，并用e返回其值，位置为 1 ~ L->length
	int i;
	if (n < 1 || n > L->length + 1)
		return ERROR;
	*e = L->data[n - 1];
	for (i = n - 1; i < L->length - 1; ++i)		//删除位置元素之后的元素前移 
		L->data[i] = L->data[i + 1];
	--L->length;
	
	return OK; 
}

Status Traverse_SqList(SqList L)
{
	int i;
	for (i = 0; i < L.length; ++i)
		printf("%d ", L.data[i]); 
}

int Locate_data(SqList L, LT e)
{
	//在线性顺序表中返回e的位置，若找到返回位置（1 ~ L.length)，否则返回-1
	int i;
	for (i = 0; i < L.length; ++i)
		if (L.data[i] == e)
			return i + 1;
			
	return -1;
}

2.单链表

一种只有后继指针的线性单向链表，无法随机存取。

//名称：LinkList()
//功能：单链表
//说明：带头结点的单链表，头插法，表头数据存放链表长度 

#include <stdio.h>
#include <stdlib.h>

#define OK						1
#define ERROR					0

typedef int Status;

//链表定义 
typedef int LT;			//ListElemType
typedef struct LNode {
	LT data;
	struct LNode * next;
} LNode, * LinkList;

//链表函数声明 
void Init_LinkList(LinkList * L);
Status Get_LinkList(LinkList L, int n, LT * e);
Status Insert_LinkList(LinkList L, int n, LT e);
Status Delete_LinkList(LinkList L, int n, LT * e);
void Traverse_LinkList(LinkList L);

int main(void)
{
	LT e;
	LinkList L;	
	Init_LinkList(&L);
	Traverse_LinkList(L);
	Get_LinkList(L, 5, &e);
	Insert_LinkList(L, 1, 9);
	Insert_LinkList(L, 7, 9);
	Traverse_LinkList(L);
	Delete_LinkList(L, 2, &e);
	printf("delete = %d\n", e);
	Traverse_LinkList(L);
	
	return 0;	
}

void Init_LinkList(LinkList * L)
{
	//使用头插法，逆序输入n个元素的值，建立带头结点的单链表L 
	int i, n;
	LNode * p;
	*L = (LNode *)malloc(sizeof(LNode));		//建立头指针 
	(*L)->next = NULL;
	(*L)->data = 0;								//头指针数据存放链表长度 
	printf("请输入链表元素的数量：");
	scanf("%d", &n);
	printf("请输入%d个链表元素：", n);
	for (i = 0; i < n; ++i)
	{
		p = (LNode *)malloc(sizeof(LNode));
		scanf("%d", &p->data);
		p->next = (*L)->next;
		(*L)->next = p;
		++(*L)->data;					//链表长度加一 
	}
}

Status Get_LinkList(LinkList L, int n, LT * e)
{
	//获得单链表L中第n个位置的元素，并用e返回其值 	（1≤n≤L->data）
	int i;
	LNode * p;
	p = L;
	if (n < 1 || n > L->data)
		return ERROR;
	for (i = 0; i < n; ++i, p = p->next);		//p指向要查找的元素
	*e = p->data;
	printf("get = %d\n", *e);
	
	return OK;
}

Status Insert_LinkList(LinkList L, int n, LT e)
{
	//在单链表L中的第n个位置之前插入元素e ( 1≤n≤L->data + 1) 
	int i;
	LNode * p, * s;
	p = L;
	s = (LNode *)malloc(sizeof(LNode));
	s->data = e;
	if (n < 1 || n > L->data + 1)
		return ERROR;
	for (i = 0; i < n - 1; ++i, p = p->next);	//p指向要插入元素的前一个元素
	s->next = p->next;
	p->next = s;
	++L->data;
	
	return OK;
}

Status Delete_LinkList(LinkList L, int n, LT * e)
{
	//在单链表L中删除第n个元素，并由e返回其值 	（1≤n≤L->data）
	int i;
	LNode * p, * s;
	p = L;
	if (n < 1 || n > L->data)
		return ERROR;
	for (i = 0; i < n - 1; ++i, p = p->next);	//p指向要删除元素的前一个元素
	s = p->next;								//s指向要删除元素
	p->next = s->next;
	*e = s->data;
	free(s);
	--L->data;
	
	return OK;
}

void Traverse_LinkList(LinkList L)
{
	int i;
	LNode * p;
	p = L->next;
	for (i = 0; i < L->data; ++i, p = p->next)
		printf("%d ", p->data);
	printf("\n");
}

3.双链表

一种有前驱指针和后继指针的线性双向链表，无法随机存取。

//名称：DuLinkList()
//功能：双链表
//说明：带头结点的双链表，头插法，表头数据存放链表长度 

#include <stdio.h>
#include <stdlib.h>

#define OK						1
#define ERROR					0

typedef int Status;

//链表定义 
typedef int LT;			//ListElemType
typedef struct DuLNode {
	LT data; 
	struct DuLNode * prior, * next;
} DuLNode, * DuLinkList;

//链表操作
void Init_LinkList(DuLinkList * L);
Status Get_LinkList(DuLinkList L, int n, LT * e);
Status Insert_LinkList(DuLinkList L, int n, LT e);
Status Delete_LinkList(DuLinkList L, int n, LT * e);
void Traverse_LinkList(DuLinkList L);

int main(void)
{
	LT e;
	DuLinkList L;	
	Init_LinkList(&L);
	Traverse_LinkList(L);
	Get_LinkList(L, 5, &e);
	Insert_LinkList(L, 1, 9);
	Insert_LinkList(L, 7, 9);
	Traverse_LinkList(L);
	Delete_LinkList(L, 2, &e);
	printf("delete = %d\n", e);
	Traverse_LinkList(L);
	
	return 0;	
}

void Init_LinkList(DuLinkList * L)
{
	//使用头插法，逆序输入n个元素的值，建立带头结点的双链表L 
	int i, n;
	DuLNode * p;
	*L = (DuLNode *)malloc(sizeof(DuLNode));		//建立头指针 
	(*L)->prior = (*L)->next = NULL;
	(*L)->data = 0;								//头指针数据存放链表长度 
	printf("请输入链表元素的数量：");
	scanf("%d", &n);
	printf("请输入%d个链表元素：", n);
	for (i = 0; i < n; ++i)
	{
		p = (DuLNode *)malloc(sizeof(DuLNode));
		scanf("%d", &p->data);
		p->next = (*L)->next;
		p->prior = (*L);
		(*L)->next = p;
		++(*L)->data;					//链表长度加一 
	}
}

Status Get_LinkList(DuLinkList L, int n, LT * e)
{
	//获得双链表L中第n个位置的元素，并用e返回其值 
	int i;
	DuLNode * p;
	p = L;
	if (n < 1 || n > L->data)
		return ERROR;
	for (i = 0; i < n; ++i, p = p->next);		//p指向要查找的元素
	*e = p->data;
	printf("get = %d\n", *e);
	
	return OK;
}

Status Insert_LinkList(DuLinkList L, int n, LT e)
{
	//在双链表L中的第n个位置之前插入元素e ( 1≤n ≤L->data + 1) 
	int i;
	DuLNode * p, * s;
	p = L;
	s = (DuLNode *)malloc(sizeof(DuLNode));
	s->data = e;
	if (n < 1 || n > L->data + 1)
		return ERROR;
	for (i = 0; i < n - 1; ++i, p = p->next);	//p指向要插入元素的前一个元素位置
	s->prior = p;		
	s->next = p->next;
	p->next = s;	
	p->next->prior = s;
	++L->data;
	
	return OK;
}

Status Delete_LinkList(DuLinkList L, int n, LT * e)
{
	//在双链表L中删除第n个元素，并由e返回其值 	（1≤n ≤L->data）
	int i;
	DuLNode * p, * s;
	p = L;
	if (n < 1 || n > L->data)
		return ERROR;
	for (i = 0; i < n - 1; ++i, p = p->next);	//p指向删除元素的前一个元素
	s = p->next;								//s指向被删除元素
	p->next = s->next;
	s->next->prior = p; 
	*e = s->data;
	free(s);
	--L->data;
	
	return OK;
}

void Traverse_LinkList(DuLinkList L)
{
	int i;
	DuLNode * p;
	p = L->next;
	for (i = 0; i < L->data; ++i, p = p->next)
		printf("%d ", p->data);
	printf("\n");
}
MiTu_-_
关注
专栏目录
顺序表的基本操作
weixin_46228933的博客
08-18 647
顺序表 定义 顺序存储方式实现的线性表 实现方式 静态分配 初始化中没有将L.data初始化，申请的内存中仍保留着之前的数据，就会出现数据污读的情况 初始化可以不给L.data初始值，但输出打印L.data时循环条件应为L.length 动态分配 用malloc函数申请一整片连续的存储空间，定义指针指向该存储空间 在没有调用增加长度函数之前，运行结果 增加动态数组的长度，先用指针p代替原指针L.data,然后申请一片比原顺序表长len的存储空间，L.data指向这片新的存储空间
数据结构之链表
gangaue的博客
04-01 5533
文章目录1.1链表的概念及结构1.2逻辑结构和物理结构1.3单链表的优势1.4单链表的实现1.5完整代码 1.1链表的概念及结构 概念： 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 实际中要实现的链表的结构非常多样，以下情况组合起来就有8种链表结构： 1、单向、双向 2、带头、不带头 3、循环、非循环 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试
L-＞data 与 L.data比较
qq_43614544的博客
03-24 7295
L->data 与 L.data比较 当L是结构体（类的）指针时，用L->data指明结构体中的变量（面向对象中，类的对象） 而当L.data则是结构体变量（类的对象），用L.data表示
数据结构 ，第一章，绪论
wofengyun的专栏
09-18 1411
一、基本概念和术语 l       数据(Data)：是指所有能输入到计算机中并被计算机程序处理的符号的总称。是计算机加工的“原料”。 l       数据元素(Data Element):是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。有些情况下，数据元素也称为元素、结点、顶点、记录。有时数据元素可以由若干数据项（也称为字段、域、属性）组成，数据项是数据的有独立含义的最小
L->data和L.data的区别
热门推荐
qq_39543837的博客
09-28 1万+
L-&gt;data中L是结构体指针； L.data中L是结构体变量； typedef struct LNode{ int data; struct LNode *next; //struct不能省略，因为typedef是在}后面才起作用。 }LNode,Linklist; //LNode是struct LNode的别名，Linklist是 struct LNod...
(c语言)顺序表的定义、初始化、增删改查 超详细~ 超好懂~
西CSun
06-01 1810
顺序表的静态分配(看成数组) 顺序表的动态分配 初始化 用malloc函数在内存中开辟一整空间 增加动态数组的长度 1.让*p和L.data指向同一位置(记住起始地址) 2.开辟一块新空间L.data 3.*p赋值给新开辟的L.data 4.free§释放原来旧的空间 插入操作 注意位序是从1开始的，数组下标是从0开始的 删除操作
数据结构课设报告，城市链表
08-09
在数据结构中，链表是一种线性数据结构，其元素（节点）在内存中不是连续存储的，而是通过指针链接。单链表每个节点包含数据域和指针域，指针域指向下一个节点。链表操作相比于数组更灵活，但访问速度相对较慢。 3....
C语言 数据结构双向链表简单实例
08-31
双向链表是一种数据结构，它可以在链表的任意位置插入或删除元素。在本实例中，我们将实现双向链表的基本操作，包括建立链表、遍历链表、删除元素、插入元素等。 1. 建立链表： 我们可以使用尾插法建立一个双向...
数据结构-使用javascript讲解数据结构之链表.zip
最新发布
02-12
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在算法和程序设计中。在JavaScript这样的动态编程语言中，理解和熟练运用链表对于提升代码效率和解决问题能力至关重要。本资料包“数据结构...
C++数据结构之链表的创建
12-26
C++数据结构之链表的创建 前言 1.链表在C/C++里使用非常频繁, 因为它非常使用, 可作为天然的可变数组. push到末尾时对前面的链表项不影响. 反观C数组和std::vector, 一个是静态大小, 一个是增加多了会对之前的元素...
数据结构---线性表
zzqingyun的博客
01-10 1983
静态分配int length;}SqList;L.length=0;return 0;动态分配#define MAXSIZE 5 //MAXSIZE是根据实际问题定义的足够大的整数常量//定义了一个指针变量存放地址int length;}SqList;//定义顺序表类型SqList L;//在C++中也可以使用new,和delete//释放空间return 0;增加数组空间的长度int length;}SqList;
L.data和L-＞data的区别
duner23的博客
10-12 1261
其次，与数组不同的是（数组名代表的是数组元素首地址），结构体名只是一个标识符而不是指针，而->是用指针访问，“."是用结构变量访问，所以实际不是这俩表达式有什么区别，而是这俩表达式里的L有区别，一个是指向结构体的指针L_1，一个是声明结构体的标识符L_2，这俩的联系应该是：struct L_2 *L_1 这样就定义了一个指向结构体L_2的指针L_1。首先，->这种表示方法只会在c和c++里出现，只有这两种语言在编程角度上真正实现了指针；
顺序表的C语言实现(静态/动态)
Curz酥的博客
08-20 1583
参考王道数据结构，含图解。
408计算机考研--数据结构--线性表学习(C语言)
Inmaturity_7的博客
06-29 662
线性表的学习 1.线性表的顺序表示–顺序表 1.1、顺序表的定义–静态分配 #include <stdio.h> #define MaxSize 10 //定义最大长度 typedef struct{ int data[MaxSize];//用数组存储数据元素 int length;//顺序表的当前长度 }SeqList;//顺序表的类型定义 //基本操作--初始化一个顺序表 void InitList(SeqList &L){ for(int i=0;i<Ma
数据结构--线性表
知足且上进，温柔而坚定
08-22 434
1 . 顺序表 2 . 单链表（不带头结点） 3 . 单链表（带头结点） 4 . 双链表 5 . 循环单链表（L指向表头结点） 6 . 循环单链表（L指向表尾结点） 7 . 循环双链表 8 . 静态链表
线性表（顺序表和链表的基本操作代码实现）
qq_54495306的博客
07-16 371
线性表的基本操作
LVM 详解
weixin_34405925的博客
03-18 700
内容：（会在后期继续整理扩充该部分内容；欢迎探讨） 1. LVM基本创建及管理 2. LVM快照 3. LVM与RAID的结合使用：基于RAID的LVM LVM创建： 描述： LVM是逻辑盘卷管理(LogicalVolumeManager)的简称,它是Linux环境下对磁盘分区进行管理的一种机制,LVM是建立在硬盘和分区之上的一个逻辑...
数据结构-顺序表--刷题记录(1)
ChadWick的博客
12-20 1912
数据结构C语言综合应用题 引用型参数和指针的区别： 首先，引用不可以为空，但指针可以为空。前面也说过了引用是对象的别名，引用为空——对象都不存在，怎么可能有别名！故定义一个引用的时候，必须初始化。 其次，引用不可以改变指向，对一个对象"至死不渝"；但是指针可以改变指向，而指向其它对象。说明：虽然引用不可以改变指向，但是可以改变初始化对象的内容。 引用是变量的一个别名，调用这个别名和调用这个变量是完全一样的。所以swap2的结果可以解释。值得注意的是，由于引用时别名，所以引用并不是一种数据类型，内存并不会给
计算机数据线性结构,数据结构与算法一 线性结构(上)
weixin_39738273的博客
07-24 323
数据结构核心名词解释数据：程序的操作对象，用于描述客观事物.特点：1>. 可以输入到计算机 2>. 可以被计算机处理数据元素：组成数据的对象的基本单位.数据对象：性质相同的数据元素的集合(类似于数组).结构：数据元素之间不是独立的,存在特定的关系.这些关系即是结构.数据结构:指的数据对象中的数据元素之间的关系.展示在代码里面就是：//声明一个结构体类型struct Teacher{ ...
数据结构：链表归并算法详解
"两个链表的归并算法分析-数据结构第一章" 在数据结构的学习中，合并两个链表是一项基础但重要的任务。这个过程涉及到对线性表的链式表示和实现的理解，特别是在处理动态数据结构时。在"数据结构第一章"中，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值