DS 0821（第二章 单链表）

最新推荐文章于 2024-04-17 12:41:51 发布
最新推荐文章于 2024-04-17 12:41:51 发布
阅读量308 收藏
点赞数
分类专栏： DS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/inf0817/article/details/108146405
版权

单链表

**单链表：**链式存储，每个结点处理存放数据元素外，还要存储指向下一个节点的指针

  1. 不要求大片的连续空间，改变容量方便
  2. 不可随机存取，要耗费一定空间存放指针

定义单链表的结点类型：

struct LNode{			//定义单链表结点类型 
	ElemType data;   	//每个结点存放一个数据元素，数据域
	struct LNode *next；	//指针指向下一个结点，指针域 
};

增加一个新的结点，在内存中申请一片空间，并用指针p指向这个结点

struct LNode *p=(struct LNode*)malloc(sizeof(struct LNode));

，之后可以使用一些代码逻辑，将p插入链表中

数据类型重命名
typedef<数据类型> <别名>

typedef struct LNode LNode;
即可以使用LNode代替struct LNode

typedef struct LNode{			//定义单链表结点类型 
	ElemType data;   	//每个结点存放一个数据元素，数据域
	struct LNode *next；	//指针指向下一个结点，指针域 
}LNode,*LinkList;

等价于

struct LNode{			//定义单链表结点类型 
	ElemType data;   	//每个结点存放一个数据元素，数据域
	struct LNode *next；	//指针指向下一个结点，指针域 
}; 
typedef struct LNode LNode;
typedef struct LNode *LinkList;  //这是一个指向LNode的指针

//要表示一个单链表时，只需声明一个头指针L，指向单链表的第一个结点，再由next指针连接

声明一个指向单链表第一个结点的指针：

LNode *L；
LinkList L

两种方式
LNode*L 强调这是一个结点
LinkList 强调这是一个链表

如何初始化一个链表

不带头节点的单链表

typedef struct LNode{			//定义单链表结点类型 
	ElemType data;   	//每个结点存放一个数据元素，数据域
	struct LNode *next；	//指针指向下一个结点，指针域 
}LNode,*LinkList; 

//初始化一个空的链表 
bool InitList(LinkList &L){
	L=NULL;          //空表，暂时没有任何结点 
	return true;
} 

//判断链表是否为空 
bool Empty(LinkList L){
	return(L==NULL);
} 

void test(){
	LinkList L; //声明一个指向单链表的指针
	//初始化一个空表
	InitList(L);
	//....后续操作 
}

带头节点的单链表

typedef struct LNode{			//定义单链表结点类型 
	ElemType data;   	//每个结点存放一个数据元素，数据域
	struct LNode *next；	//指针指向下一个结点，指针域 
}LNode,*LinkList; 

//初始化一个带头节点的链表 
bool InitList(LinkList &L){
	L=(LNode*)malloc(sizeof(LNode));  //分配一个头节点 
	if(L==NULL)					//内存不足，分配失败 
	return false;
	L->next =NULL;				//头结点之后暂时还没有结点 
	return true;
}    							//头结点不存储数据 

//判断链表是否为空 
bool Empty(LinkList L){
	return(L->next==NULL);
} 

void test(){
	LinkList L; //声明一个指向单链表的指针
	//初始化一个空表
	InitList(L);
	//....后续操作 
}

带头节点，写代码更方便

单链表的操作

插入删除

1. 带头节点的的按位序插入

LIstInsert(&L,i,e):插入操作，在表中第i个位置，插入指定元素e
找到第i-1个结点，修改其next值，头节点可以看作第0个位置

typedef struct LNode{			//定义单链表结点类型 
	ElemType data;   	//每个结点存放一个数据元素，数据域
	struct LNode *next；	//指针指向下一个结点，指针域 
}LNode,*LinkList;

//在第i个位置插入元素e（带头节点） 
bool ListInsert(LinkInsert &L,int i,elemType e) {
	if(i<1)  return false;
	LNode *p;     //指针p指向当钱扫描到的结点
	int j=0;      //当前p指向的是第几个结点
	p=L;          //L指向头节点，头节点是第0个结点（不存数据）
	while(p!=NULL&&j<i-1){
		//循环找到第i-1个结点
		p=p->next;
		j++; 
	} 
	if(p==NULL)
	return false;
	
	LNode *s=(LNode*)malloc(sizeof(LNode));
	s->data =e;
	s->next=p->next;   //这一句 
	p->next=s;		   //与这一句不可以颠倒 
	return true;
}

平均时间复杂度O（n）

2. 不带头节点的按位序插入（因为不带头节点所以i=1需要特殊处理）

typedef struct LNode{			//定义单链表结点类型 
	ElemType data;   	//每个结点存放一个数据元素，数据域
	struct LNode *next；	//指针指向下一个结点，指针域 
}LNode,*LinkList;

//在第i个位置插入元素e（带头节点） 
bool ListInsert(LinkInsert &L,int i,elemType e) {
	if(i<1)  return false;
	
	if(i==1){
		//插入第一个结点的操作与其他不同
		 LNode *s=(LNode*)malloc(sizeof(LNode));
		 s->data=e;
		 s->next=L;
		 L=s; //头指针指向新结点 
		 return true; 
	} 

	LNode *p;     //指针p指向当钱扫描到的结点
	int j=0;      //当前p指向的是第几个结点
	p=L;          //L指向头节点，头节点是第0个结点（不存数据）
	while(p!=NULL&&j<i-1){
		//循环找到第i-1个结点
		p=p->next;
		j++; 
	} 
	if(p==NULL)
	return false;
	
	LNode *s=(LNode*)malloc(sizeof(LNode));
	s->data =e;
	s->next=p->next;   //这一句 
	p->next=s;		   //与这一句不可以颠倒 
	return true;
}

不带头节点的话，则插入和删除第一个元素时，需要更改头指针L

3指定结点的后插操作

bool InsertNextNode(LNode *p,ElemType e){
	if(p==NULL)
	return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));
	if(s==NULL)   return false;    //内存分配失败 
	s->data=e;
	s->next=p->next;
	p->next=s;
	return true;
}

可以替换插入操作的后半部分：return InsertNextNode（p，e）

4.指定结点的前插操作
Q：如何找到p的前驱结点

  1. 传入头指针bool InsertPriorNode(LinkList L,LNode *p,elemtype e)
    循环查找p的前趋q，再对q后插 ，时间复杂度为O（n）
  2. 在p结点之后插入一个结点，将p的值复制到该节点中，并将e传入到p结点中 ，时间复杂度为O（1）
bool InsertPriorNode(LNode *p,ElemType e){
	if(p==NULL)
	return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));
	if(s==NULL)   return false;    //内存分配失败 
	s->next=p->next;
	p->next=s;
	s->data=p->data;
	p->data=e;
	return true;
}

5.带头节点的按位序删除
ListDelete（&L，i，&e）：删除操作。删除表中第i个位置的元素，并用e返回删除元素的值

找到第i-1个节点，将其指针指向i+1个结点，并释放第i个结点

typedef struct LNode{			//定义单链表结点类型 
	ElemType data;   	//每个结点存放一个数据元素，数据域
	struct LNode *next；	//指针指向下一个结点，指针域 
}LNode,*LinkList;

bool ListDelete(LinkList &L,int i,ElemType &e){
	if(i<1)  return false;
	LNode *p;	//指针p指向当前扫描到的结点 
	int j=0;	//当前p指向的是第几个结点 
	p=L;		//L指向头节点，头节点是第0个结点（不存数据）
	while(p!=NULL&&j<i-1){
		//循环找到第i-1个结点
		p=p->next;
		j++; 
	} 
	if(p==NULL)   //i值不合法
	return false;
	if(p->next==NULL) //第i-1个结点后已无其他结点 
	return false; 
	
	LNode *q=p->next; //让q指向被删除的结点
	e=q->data;       //用e返回被删除的值
	p->next=q->next;
	free(q);
	return true; 
}

最坏，平均时间复杂度O（n）

6.指定结点的删除
bool DeleteNode（LNode *p）
Q：删除结点p需要找到他的前趋结点的next指针

  1. 传入头指针，循环寻找p的前趋结点
  2. 偷天换日
bool DeleteNode(LNode *p){
	if(p==NULL)
	return false;
	
	LNode *q=p->next;  //让q指向p的后继结点
	p->data=p->next->data;  //p和后继结点q交换数据域 
	p->next=q->next;		// 将*q结点从连中断开 
	free(q);
	return true; 
}

如果p是最后一个结点，只能从表头开始依次寻找p的前驱，时间复杂度O（n）

  • 单链表的局限性：无法逆向检索，有时候不太方便

单链表的查找操作

只讨论带头节点的情况
GetElem（L，i）：按位查找操作，获取表中第i个位置的元素的值
LocateElem（L，e）：按值查找操作。在表L中查找具有给定关键字值的元素。

注：在插入和删除中已经进行了查找的操作，找到i-1罢了

1. 按位查找

LNode*GetElem(LinkList L,int i){
	if(i<0)
		return NULL;
	LNode *p;	//指针p指向当前扫描到的结点
	int j=0;	//当前p指向的是第几个结点
	p=L;		//L指向头节点，头节点是第0个结点
	while(p!=NULL&&j<i){
		//循环找到第i个结点
		p=p-next;
		j++; 
	} 
	return p;
}

平均时间复杂度O（n）

2. 按值查找

LNode*LocateElem(LinkList L,ElemType e){
	LNode *p=L->next;
	//从第一个结点开始查找数据域为e的结点
	while(p!=NULL&&p->data!=e)
	p=p->next;
	return p; //找到后返回该结点的指针，否则返回NULL 
}

求表的长度

int Length(LinkList L){
	int len=0;
	LNode *p=L;
	while(p->next!=NULL){
		p=p->next;
		len++;
	}
	return len;
}

单恋表的两种建立方法：头插法，尾插法

带头节点的单链表的情况
尾插法

  1. 初始化单链表
  2. 设置变量length记录链表长度
  3. while{
    每次取出一个元素e；
    ListInsert（L，length+1，e）
    length++；
    }
  4. 每次都从头开始遍历，时间复杂度为O（n²）

后插操作

LinkList List_TailInsert(LinkList &L){   //正向建立单向表 
	int x;								 //设ElemType为整形
	L=(LinkList)malloc(sizeof(LNode));   //建立头节点，初始化空表
	LNode *s，*r=L;						 //r为表尾指针
	scanf("%d",&x);						 //输入结点的值
	while(x!=9999){						 //输入9999表示结束 
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
		r->next=s;						 //在r结点之后插入元素x
		r=s;							 //r指向新的表尾结点，永远保持r指向最后一个结点
		scanf("%d",&x); 
	} 
	r->next=NULL;
	return L;
}

头插法建立单链表

每一次取得一个新的数据元素，都插入到单链表的表头的位置

  • 即每次都对头节点进行一次后插操作
LinkList List_HeadInsert(LinkList &L){   //正向建立单向表 
	LNode *s;
	int x;
	L=(LinkList)malloc(sizeof(LNode));  //创建头节点
	L->next=NULL;                       //初始为空链表，注意尾插法没有这一步
	scanf("%d",&x);						//输入结点的值 
	while(x!=9999){
		s=(LNode *)malloc(sizeof(LNode));//创建新结点
		s->data=x;
		s->next=L-next;
		L-next=s;						//将新结点插入表中，L为头指针 
		scanf("%d",&x); 
	} 
		return L; 
}
  1. 好习惯：只要是初始化单链表，都先把头指针指向NULL
  2. 重要应用：链表的逆置
zl！ght
关注
专栏目录
Java：当需要创建链表并返回头结点的时候
qq_44688635的博客
04-29 1042
创建链表，或者改变已有链表的时候，如果我们只声明了一个结点，这个结点需要不断地往链表尾部移动，最后我们无法返回该结点作为头结点。 此时，我们可以用下面这个方法来解决这个问题。（注意看注释部分） 可以参考leetcode算法题23. 合并K个排序链表中的分治算法解法，将会遇到这个问题，可以用这个方法来解决。 class ListNode { int val; ListNode nex...
DS 0824（第二章 双链表等）
INF0817的博客
08-27 283
双链表 单链表与双链表对比 单链表只有一个指向后继结点的指针，所以如果给定结点p想要找到他的前趋结点很麻烦，无法逆向检索 双链表在单链表的基础上，增加了一个指针域，指向其前趋结点。可进可退，存储密度更低 typedef struct DNode{ //定义双链表结点数据类型 ElemType data; //数据域 struct DNode *prior,*next; //前趋和后继指针 }DNode,*DLinkList; 带头节点双链表的初始化 typedef st
数据结构之单链表
月小水长
09-12 448
从今天起开始数据结构系列的分享，今天分享的是单链表。单链表大概是大概是每个数据结构 初学者的必经之路，下面结合一个小小的工程深入学习单链表的使用–简易客户管理系统。 ps：如果还不清楚单链表是什么的小伙伴自行百度，在此不在赘述 项目结构 如图所示 大致了解了项目架构后，下面开始从零编写代码 注：增、删、改这三个部分同时包含了将变动后的信息写入到文件中的操作 ...
6-178 寻找链表元素的前驱结点
m0_73975449的博客
04-17 286
本题要求实现一个函数，可查找单链表(无监督元)中某个元素的前驱结点。例如链表中的元素为1，6，3，2，4，查找3的前驱为6。如果表中无此元素或没有前驱则返回空指针。
查找单链表的某个节点，并返回该节点的前继指针
xyl_20171026的博客
06-25 135
在这个例子中，我们定义了一个Node结构体，包含一个整数data和一个指向下一个节点的指针next。我们还定义了一个find_previous函数，它接受一个指向链表头节点的指针head和一个指向目标节点的指针target，并返回目标节点的前继节点的指针。在循环中，我们使用previous指针来记录当前节点的前继节点，然后将current指针移动到下一个节点。我们调用find_previous函数来查找目标节点的前继节点，并将返回的指针赋值给previous变量。
单链表简单操作
jinqg的博客
01-04 871
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef char datatype; typedef struct node { datatype data; //节点数据 struct node *next;//节点指针 }linklist; //链表建立 //返回：头指针 linklist * creat_list()...
数据结构(C语言第2版) 课后习题答案之第二章 线性表
热门推荐
Yummy的博客
04-12 1万+
目录 第二章 线性表 1．选择题 （1）一个向量第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（ ）。 （2）在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是（ ）。 （3）向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动的元素个数为（ ）。 （4）链接存储的存储结构所占存储空间（ ）。 （5）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（ ）。 （6）线性表Ｌ在（ ）情况下适用于使用链式结构...
数据结构第二章课后习题第十题（删除顺序表中值为item的元素）
qq_62175345的博客
04-24 3236
已知长度为n的线性表A采用顺序存储结构，请写一时间复杂度为O（n）、空间复 杂度为O（1）的算法，该算法删除线性表中所有值为item的数据元素。 #include <iostream> #define ok 1 #define error 0 #define overflow -2 #define MaxSize 100 using namespace std; typedef int status; typedef int ElemType; //定义 typedef struct .
数据结构王道强化应用题打卡表【第二章】（代码部分）
sxy258的博客
10-02 2878
2.4 - 2.6使用rear指向队列最后一个元素的方法（就是把上一点里的rear往前移一个位置，操作时需要+1）入队在rear后面，出队在head的后面（head还是那个head，不变）2.1 - 2.3使用rear指向下一个要插入的位置的方法。栈顶在链头，实现“出栈、入栈、判空、判满”四个基本操作。定义顺序存储的队列（数组实现），不要求循环。实现“出队、入队、判空、判满”四个基本操作。要求数组空间可以循环利用（修复上述bug）写代码：定义链式存储的栈（单链表实现）王道官方数据结构应用题打卡表——
DS 0901（第三章 队列）
INF0817的博客
09-07 269
队列 Queue 线性表：线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长。当n=0时，线性表是一个空表 栈：是只允许在一端进行插入和删除的线性表 队列：是只允许在一端进行插入，在另一端进行删除的线性表（入队，出队） terms：队头，队尾，空队列 ...
类实现一简单链表 用类的形式以及链表 结点
11-05
用类实现一个简单的链表。其数据类型为int型。实验上做的，没太多技术含量。
数据结构 线性表-2 链式存储
qq_42731129的博客
06-27 287
数据结构 线性表-2 链式存储引言单向链表组成描述基本操作单链表的不足循环链表结构循环链表检索双向链表结构描述 引言 链式存储结构指用一组任意的存储单元(可以连续，也可以不连续)存储线性表中的数据元素,而数据元素之间的逻辑关系由存储结点的指针域来确定。 特点 1、 线性表中的数据元素在存储单元中的存放顺序与逻辑顺序不一定一致； 2、 访问数据元素时，只能由头指针进入链表，并通过结点的指针域向后扫描其余结点，这样访问不同数据元素所花的时间是不相等的，具有这种特点的存取方式被称为顺序存取方式。 单向链表 组成
2021-12-09
Mo_SFish的博客
12-10 2108
C++学习笔记（23） 1.动态链表的每个结点存放元素的自身信息和与之关联的元素的地址。 单向链表只需存放直接后继节点的地址，双向链表既有直接前驱也有直接后继节点的地址。 结构成员可以是指向自身结构类型的指针，但不能是自身结构类型的变量。 2.建立链表: struct Node {int data; Node * next; }; //①定义链表结构体; Node * head=NULL; //②定义头指针； void CreateList(Node * & head) //
问题 A: DS单链表--类实现
elapse_的博客
03-16 1094
问题 A: DS单链表–类实现 时间限制: 1 Sec 内存限制: 128 MB 题目描述 用C++语言和类实现单链表，含头结点 属性包括：data数据域、next指针域 操作包括：插入、删除、查找 注意：单链表不是数组，所以位置从1开始对应首结点，头结点不放数据 类定义参考 输入 n 第1行先输入n表示有n个数据，接着输入n个数据 第2行输入要插入的位置和新数据 第3行输入要插入的位置和新数据 第4行输入要删除的位置 第5行输入要删除的位置 第6行输入要查找的位置 第7行输入要查找的位置 输出 n 数
DS之单链表
Lwolwo's
09-17 2045
DS之单链表的类实现、结点交换、合并操作。
数据结构一
好的博客
12-29 514
用C++语言和类实现单链表，含头结点属性包括：data数据域、next指针域操作包括：插入、删除、查找注意：单链表不是数组，所以位置从1开始对应首结点，头结点不放数据类定义参考数据之间用空格隔开，第1行输出创建后的单链表的数据每成功执行一次操作（插入或删除），输出执行后的单链表数据每成功执行一次查找，输出查找到的数据如果执行操作失败（包括插入、删除、查找等失败），输出字符串error，不必输出单链表 例题 一元多项式 对于一元多项式 p(x)=p0+p1x+p2x2+ … +pnxn， 每个项都有系数和指数
DS单链表--类实现
秦怀杂货店
11-06 1989
用C++语言和类实现单链表，含头结点 属性包括：data数据域、next指针域 操作包括：插入、删除、查找 注意：单链表不是数组，所以位置从1开始对应首结点，头结点不放数据 输入 n 第1行先输入n表示有n个数据，接着输入n个数据 第2行输入要插入的位置和新数据 第3行输入要插入的位置和新数据 第4行输入要删除的位置 第5行输入要删除的位置 第6行输入要查找的
类实现--单链表基本操作(C++)
wjher
07-26 601
类实现，单链表 节点类 Node 节点 应包括数据值 data 以及指向下一个节点的指针 next。 #include<iostream> using namespace std; typedef int DataType; //自定义数据类型 class Node { public: //对节点类私有数据相关操作函数 Node() {} ~Node()...
单链表--C++类的实现
qq_74910357的博客
11-26 1116
链表是线性表的链式存储形式用任意一组存储单元存储数据，可以是连续的，也可以是不连续的其中结点由数据域和指针域两部分组成链表的第一个结点的存储位置叫做头指针最后一个结点指针设为NULL单链表会在第一个结点前设置一个结点，叫做头结点头结点和头指针的区别：头指针是链表指向第一个结点的指针，如果有头结点，则是指向头结点的指针头指针是链表的必要元素，而头结点不是头结点是为了操作统一方便而设立的结点的代码实现。
DS单链表—删除重复元素
最新发布
09-15
DS（Data Structure）单链表是一种线性数据结构，其中每个节点包含数据和指向下一个节点的指针。删除重复元素是指从给定的单链表中移除所有相等的值，保留每个值第一次出现的位置。 一种常见的方法是遍历链表，使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值