【数据结构2】链表

最新推荐文章于 2023-08-30 15:02:34 发布
最新推荐文章于 2023-08-30 15:02:34 发布
阅读量2.7k 收藏 15
点赞数 7
分类专栏： 数据结构 文章标签： 数据结构 单链表 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014134180/article/details/54091157
版权

文章目录


由于顺序表的 插入和 删除操作需要移动大量元素，影响了效率。 链式存储不要求逻辑上相邻的两个元素在物理位置上也相邻，而是通过“链”建立起数据元素的逻辑关系。因此，在链表的插入和删除不需要移动元素，只需修改指针。
链式存储的线性表称为 链表。其中每个结点（Node）只包含一个数据域和一个指针域的链表称为 单链表，首尾相连的单链表称为 循环单链表。每个结点只包含一个数据域和两个指针域的链表称为 双链表，首尾相连的双链表称为 循环双链表。还有一种链表称为 静态链表，该链表也有数据域和指针域，这里的指针是结点相对地址（数组下标），又称为 游标（cur），静态链表和顺序表一样要预先分配一块连续的内存空间。

1单链表

1.1结点定义

通常用头指针来标识一个单链表，如单链表L（LinkList L;），L=NULL时表示一个空表。因此，为了操作方便就在单链表的首元结点前附加一个结点，即头结点（LinkList L=(LinkList)malloc(sizeof(LNode));）。头结点数据域可以不带今后任何信息，但可记录链表长度，头结点指针域则指向首元结点。此时判断带头结点为空的条件为：L->next==NULL。
这里写图片描述
单链表结点定义为：

typedef struct LNode{	//定义单链表结点类型 
	ElemType data;		//数据域 
	struct LNode *next;	//指针域 
}LNode,*LinkList;		//LinkList相当于LNode*，即：struct LNode*

##1.2头插法建立单链表

头插法建立单链表

#include<stdio.h>		//NULL
#include<malloc.h>		//malloc
#define ElemType int
typedef struct LNode{	//定义单链表结点类型 
	ElemType data;		//数据域 
	struct LNode *next;	//指针域 
}LNode,*LinkList;		//LinkList相当于LNode*，即：struct LNode*
//头插法建立单链表 
LinkList ListCreat_L_FromHead(){
	LinkList L=(LinkList)malloc(sizeof(LNode));
	L->next=NULL;
	int e,length=0;
	printf("请输入插法建立单链表元素（以-1结束）\n");
	scanf("%d",&e);
	while(e!=-1){
		LNode *s=(LNode*)malloc(sizeof(LNode));
		s->data=e;
		s->next=L->next;
		L->next=s;
		length++;
		scanf("%d",&e);
	}
	L->data=length;		//令头结点记录链表长度 
	return L;
}
int main(){
	LinkList L= ListCreat _L_FromHead();
	printf("单链表元素个数：%d 分别是：",L->data);
	for(LNode* N=L->next;N;N=N->next){
		printf("%d ",N->data);
	}
	return 0;
}

##1.3尾插法建立单链表

尾插法建立单链表

#include<stdio.h>		//NULL
#include<malloc.h>		//malloc
#define ElemType int
typedef struct LNode{	//定义单链表结点类型 
	ElemType data;		//数据域 
	struct LNode *next;	//指针域 
}LNode,*LinkList;		//LinkList相当于LNode*，即：struct LNode*
//尾插法建立单链表 
void ListCreat _L_FromTail(LinkList &L){
	L=(LinkList)malloc(sizeof(LNode));
	L->data=0;L->next=NULL;	//L->data为链表长度 
	LNode *r=L;				//r为表尾指针 
	printf("请输入插法建立单链表元素（以-1结束）\n");
	int e;scanf("%d",&e);
	while(e!=-1){
		LNode *s=(LNode*)malloc(sizeof(LNode));
		s->data=e;s->next=NULL;
		r->next=s;
		r=r->next;
		L->data++;			//链表长度+1
		scanf("%d",&e);
	}
}
int main(){
	LinkList L;
	ListCreat _L_FromTail(L);
	printf("单链表元素个数：%d 分别是：",L->data);
	for(LNode* N=L->next;N;N=N->next){
		printf("%d ",N->data);
	}
	return 0;
}

##1.4按序号查找表结点

//按序号查找第i个结点 
LNode* ListGetElem_L (LinkList L,int i){
	LNode* p=L->next;		//p为首元结点
	if(i==0)return L;		//返回头结点
	if(i<0)return NULL;		//i无效返回NULL
	for(int j=1;j<i&&p;j++){
		p=p->next;
	} 
	return p;				//返回第i个结点指针；若i>表长则返回的是NULL 
}

##1.5按值查找表结点

//按值e查找表结点 
LNode* ListLocate_L (LinkList L,int e){
	LNode* p=L->next;		//p为首元结点
	while(p->data!=e&&p){
		p=p->next;
	} 
	return p;				//返回第i个结点指针；若i>表长则返回的是NULL 
}

##1.6插入结点操作
在第i个位置插入结点要先查找插入位置的前驱结点，单链表插入要执行两步必要操作：

  • 把新结点s挂接后继结点并赋值；
  • 把新结点挂在前驱结点p。

这里写图片描述

//在第i个位置插入结点操作 
bool ListInsert_L(LinkList &L,int i,int e){
	LNode* p= ListGetElem_L(L,i-1);	//查找插入位置的前驱结点 
	if(p==NULL)return false;	//i定位无效，插入失败返回false 
	LNode* s=(LNode*)malloc(sizeof(LNode));	//为新值分配结点空间 
	s->next=p->next;			//1.把新结点s挂接后继结点p->next
	s->data=e;					// 新结点赋值
	p->next=s;					//2.把新结点s挂在前驱结点p
	return true;				//插入成功返回true 
}

##1.7删除结点操作
删除第i个结点要先查找删除位置的前驱结点，单链表删除要执行也两步必要操作：

  • 将前驱结点p指向预删除结点的后继结点；
  • 释放预删除结点空间。

这里写图片描述

//删除第i个结点操作 
bool ListDelete_L(LinkList &L,int i,int &e){
	LNode* p=ListGetElem_L(L,i-1);	//查找删除位置的前驱结点 
	if(p||p->next)return false;	//i定位无效，删除失败返回false 
	LNode* s=p->next;			//将s指向预删除结点p->next
	e=s->data;					//将预删除结点s的值赋给e引用传回
	p->next=p->next->next;		//将前驱结点p指向预删除结点的后继结点
	free(s);					//释放预删除结点空间
	return true;				//删除成功返回true 
}

##1.8合并有序链表
将两个有序单链表La和Lb合并为一个有序单链表Lc。

//合并有序链表 
void ListMerge_L(LinkList &La,LinkList &Lb,LinkList &Lc){
	LNode* pa=La->next,*pb=Lb->next;
	LNode* pc=Lc=La;				//用La头结点作为Lc的头结点 
	Lc->data=La->data+Lb->data;		//Lc的长度为La长度与Lb长度之和
	while(pa&&pb){
		if(pa->data<pb->data){		//按非递减归并 
			pc->next=pa;pc=pa;pa=pa->next;
		}else{
			pc->next=pb;pc=pb;pb=pb->next;
		}
	} 
	pc->next=pa?pa:pb;				//插入剩余段 
	free(Lb);						//释放Lb的头结点 
}

#2循环双链表
循环双链表定义头结点要维护循环双链表规则，即：L->next=L->prior=L;。若DLNode *p=L->next;…;p=p->next;，则判断循环双链表为空的条件是p==L;。
##2.1结点定义
这里写图片描述

#include<stdio.h>
#include<stdlib.h>
#define ElemType int
typedef struct DLNode{
	ElemType data;
	struct DLNode *prior,*next;
}DLNode,*DLinkList;

int main(int argc,char ** argv ){
	DLinkList L=(DLinkList)malloc(sizeof(DLNode));
	L->next=L->prior=L;		//维护循环双链表规则 
	return 0;
}

##2.2插入和删除操作
这里写图片描述

//双循环双链表第i个位置插入e 
bool ListInsert_DL(DLinkList &L,int i,ElemType e){
	if(i<=0)return false;
	DLNode *p=L;
//	for(int j=1;j<i;j++,p=p->next);			//方式一：p是s的前驱 
	for(int j=0;j<i;j++,p=p->next);			//方式二：p是s的后继 
	DLNode* s=(DLNode*)malloc(sizeof(DLNode));
	if(!s)return false;
	s->data=e;
//	s->next=p->next;s->prior=p->next->prior;//方式一：p是s的前驱 
//	p->next->prior=s;p->next=s;
	s->prior=p->prior;p->prior->next=s;		//方式二：p是s的后继 
	s->next=p;p->prior=s;
	return true;
}

#3循环单链表
#4带尾指针的循环单链表
#5静态链表
静态链表的插入、删除操作和动态链表的相同，只需修改指针（游标），而不需移动元素。但静态链表使用没有比单链表的方便，但对于一些不支持指针的高级语言（Basic语言）又是一种巧妙的设计方法。
我们用一个例子来说明静态链表的用法。现求集合(A-B)||(B-A)的元素，即遍历B中元素，如果A中没有该元素则插入A，否则删除从A中该元素。
这里写图片描述

#include<stdio.h>
#define MAXSIZE 11 				//减去空闲链表和占用链表两个头指针，有MAXSIZE-2个空闲可以分配 
#define ElemType char
typedef struct{
	ElemType data;				//值域 
	int cur;					//游标 
}component,SLinklist[MAXSIZE];

	int s;
	SLinklist SL;
void Print();	//声明 Print函数 

/*初始化一维数组space为空闲链表，space[0].cur为头指针*/
void InitSpace_SL(SLinklist &space){
	for(int i=0;i<MAXSIZE;i++)
		space[i].cur=i+1;
	space[MAXSIZE-1].cur=0;	
}
/*从空闲链表分配一个空间以下标i返回,空闲链表空间不够则返回0*/
int Malloc_SL(SLinklist &space){
	int i=space[0].cur;
	if(space[0].cur)space[0].cur=space[i].cur;
	return i;
}
//回收下标为k的空闲结点到空闲链表 
void Free_SL(SLinklist &space,int k){
	space[k].cur=space[0].cur;
	space[0].cur=k;
}

/*求集合(A-B)||(B-A)*/
void difference(SLinklist &space,int &S){
	InitSpace_SL(space);			//初始化空闲链表 
	S=Malloc_SL(space);				//生成占用链表S的头结点 
	int m,n,r=S;					//r表示占用链表S当前最后结点 
	printf("input the number of A and B: ");
	scanf("%d %d",&m,&n);getchar();	//输入A和B的元素个数 
	
	/*将A元素加入占用链表 */
	for(int j=1;j<=m;j++){			
		int i=Malloc_SL(space);
		printf("input the data of A one by one with a Enter: ");
		scanf("%c",&space[i].data);getchar();//
		space[r].cur=i;		r=i;
		//Print();//
	}
	space[r].cur=0;					//尾结点指针域为0 
	Print();//
	
	/*依次输入B的元素，若不在当前占用链表S中，则插入；否则删除 */
	for(int j=1;j<=n;j++){			
		printf("input the data of B one by one with a Enter: ");
		ElemType b;scanf("%c",&b);getchar();//
		int p=S;
		int k=space[S].cur;
		while(k!=space[r].cur&&space[k].data!=b){
			p=k;k=space[k].cur;	//p表示k的前一个元素 
		}
		if(k==space[r].cur){	//该元素不在占用链表S中，插入之 
			int i=Malloc_SL(space);
			space[i].data=b;
			space[i].cur=space[r].cur;
			space[r].cur=i;
			r=i;				//表尾r指向最新元素 
		}else{					//该元素已在占用链表S中，删除之 
			space[k].data=' ';	//把删除的值清空 
			space[p].cur=space[k].cur;
			Free_SL(space,k);
			if(r==k)r=p;		//若删除的是r所结点，则需修改尾指针 
		}
		
		Print();//
	}//for
}

int main(int argc,char ** argv){
	difference(SL,s);
	printf("data head index s: %d\n",s);
	return 0;
}

/*定义 Print函数 */
void Print(){
	printf("index:\t");
	for(int i=0;i<MAXSIZE;i++){
		printf("%d\t",i);
	}printf("\n");
	printf("data:\t");
	for(int i=0;i<MAXSIZE;i++){
		printf("%c\t",SL[i].data);
	}printf("\n");
	printf("cur:\t");
	for(int i=0;i<MAXSIZE;i++){
		printf("%d\t",SL[i].cur);
	}printf("\n\n");
	printf(":----------------------------------\n");

}

Wu_Being 博客声明：本人博客欢迎转载，请标明博客原文和原链接！谢谢！
【数据结构系列】《【数据结构2】链表》http://blog.csdn.net/u014134180/article/details/54091157
我的GitHub代码文件：https://github.com/1040003585/Data_Structure

Wu_Being
关注
  • 7
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
订阅专栏
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
【数据结构】单链表的按位查找（带头结点的和不带头结点的）和按值查找
bbt953的博客
10-12 350
单链表的按位查找（带头结点的和不带头结点的）和按值查找
单链表
weixin_40805072的博客
08-05 4125
一、基本概念 带头结点和不带头结点的单链表 带头结点的单链表，头指针head指向头结点，头结点的值域不包含任何信息，从头结点之后的结点开始存储信息。 头指针head不等于NULL，head->next等于NULL时，链表为空。 单链表结点定义 typedef struct LNode{ int data; //data存放结点数据域 stru...
单链表查找第i个节点
10-16 3797
1 #include<stdio.h> 2 #include<string.h> 3 #include<stdlib.h> 4 typedef struct Node 5 { 6 char a; 7 struct Node* next; 8 }Node,*list; 9 void p(list L)...
【数据结构】链表
knous
03-13 6万+
链表
继续带头结点的单链表的插入操作
weixin_52634719的博客
09-19 1549
先找到第i-1个结点，然后用指针变量P指向它 然后生成一个新结点，用指针S指向它，然后数据域赋值为e，然后将它插入 ai变成了新结点的后继，s的next域赋值给ai这个结点的地址 而ai这个结点的地址在ai-1的next域里存着。所以将next域的值赋值给他，也就是ai这个结点的地址赋值给新结点的Next域 i-1这个元素用指针p指向它，指针p的next域的值也就是ai的地址p->next，赋值给新结点的next域，然后这个指针就生成了，这是第一步。 第二步将...
数据结构---单向链表，双向链表，单向环形链表
root1994的博客
07-09 4834
链表介绍 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域:指向下一个节点. 如图:发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 修改节点功能 思路(1) 先找到该节点，通过遍历，(2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.n...
Python数据结构之链表实现
最新发布
02-27
1.使用Python语言实现链表数据结构 2.基于类封装思想 3.实现链表增删改查功能 4.有测试数据
数据结构C++链表
03-04
基于C++的数据结构单链表，带主程序可运行，使用头文件可直接编程。
01基础数据结构之链表
09-14
基础数据结构之链表
数据结构C语言链表的实现
04-18
数据结构C语言链表的实现
[数据结构]——链表详解
m0_62023005的博客
09-19 3752
数据结构---链表详解
链表基础知识详解（非常详细简单易懂）
热门推荐
qq_61672347的博客
07-10 15万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
线性表及其链式存储
qq_53092980的博客
06-20 248
1.单链表的头文件 typedef int datatype; typedef struck link_node{ datatype info; struck link_node *next; }node; typedef node *linklist;
链表（超详细--包教包会）
Lushengshi的博客
02-20 4423
C\C++ 链表 包教包会
数据结构（一）--- 链表
weixin_53072248的博客
08-05 2191
数据结构概述：在计算机中存储和组织数据的方式。算法概述：解决方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。算法复杂度O(1) 常数阶O(log(n)) 对数阶O(n) 线性阶O(nlog(n)) 线性和对数乘积O(n2) 平方阶O(2n) 指数阶既可以从头遍历到尾，又可以从尾遍历到头。也就是说链表连接的过程是双向的，它的实现原理是：一个节点既有向前连接的引用，也有一个向后连接的引用。
链表（详解）
m0_69323023的博客
08-30 3485
1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。2、结点包括两个部分：（1）存储数据元素的数据域（内存空间），（2）存储指向下一个结点地址的指针域。3、相对于线性表顺序结构，操作复杂。
C语言数据结构——链表
zcxmjw的博客
12-22 1万+
大家好，本篇文章主要带领大家了解一下什么是链表，链表的两个主要结构，以及链表和顺序表的差别。
链表（C语言版）超详细讲解
h220321204的博客
08-15 8749
而如果使用头插法，则需要遍历到链表的第一个节点，时间复杂度为O(n)，而且尾插法是由数据插入的顺序依次存储的，查找起来会更加方便。1、首先我们定义两个指针（x1,p）,x1作为头指针指向头结点（尾插法时不要移动头指针，我们只需移动p即可），p始终指向尾结点（这里我们初始化指向头结点），再申请一块结点并用x指向它。这样我们基础工作完成。
数据结构python链表
11-05
链表是一种常用的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表可以分为单向链表和双向链表两种类型。在Python中，我们可以通过定义节点类和链表类来实现链表数据结构。节点类包含...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值