单链表的基本操作

最新推荐文章于 2024-06-13 21:23:54 发布
最新推荐文章于 2024-06-13 21:23:54 发布
阅读量2.9k 收藏 25
点赞数 8
分类专栏： C语言基础向 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64084604/article/details/127947499
版权

一、代码定义单链表

#伪代码

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

1.声明一个单链表时，只需声明一个头指针L，指向单链表的第一个结点；

2.上面代码段中两种重命名方式等价，按所需场景不同分别应用：

        ①强调是单链表时用LinkList L;

        ②强调是结点时用LNode* L。

3.下文中所提到的单链表的基本操作，其定义均以上文的代码段为准。

二、单链表的初始化

1.有头结点的单链表

①初始化函数

#伪代码

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

②判空函数

#伪代码

bool Empty(LinkList L)
{
	if (L->next == NULL)
		return true;
	else
		return false;
}

2.无头结点的单链表

①初始化函数

#伪代码

bool InitList(LinkList& L)
{
	L = NULL;						//空表 暂时还没有任何结点
	return true;
}

②判空函数：

#伪代码

bool Empty(LinkList L)
{
	return (L == NULL);
}

三、插入操作

1.按位序插入（带头结点）

①ListInsert(&L,i,e):插入操作：在表L中的第i个位置上插入指定元素e。

②代码实现：

#伪代码

bool ListInsert(LinkList& L, int i, int e)
{
	if (i < 1)
		return false;
	LNode* p;									//指针p指向当前扫描到的结点
	int j = 0;									//j代表当前p指向的是第几个结点
	p = L;										//L指向头结点，头结点是第0个结点，不存数据
	while (p != NULL && j < i - 1)				//循环找到第i-1个结点
	{								
		p = p->next;
		j++;
	}
	if (p == NULL)								//i值不合法
		return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;							//将结点s连到p之后
	p->next = s;								//将结点p连到s上
	return true;								//插入成功
}

③补充解释：要实现在第i个结点上插入，应该找到第i-1个结点然后对第i-1个结点的后继结点进行操作，所以while循环结束之前都是寻找第i-1个结点的操作；之后是对新结点的插入操作。

④此操作平均时间复杂度为O(n)。

2.按位序插入（无头结点）

①ListInsert(&L,i,e):插入操作：在表L中的第i个位置上插入指定元素e。

②区别在于不存在第0个结点，因此在i=1时要进行特殊处理。

③代码实现：

#伪代码

bool ListInsert(LinkList& L, int i, int e)
{
	if (i < 1)
		return false;
	if (i == 1)                     //对i=1这一种特殊情况的操作，其余基本不变
	{
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L = s;
		return true;
	}
	LNode* p;										
	int j = 1;						//这里j=1而不是=0，因为p指针刚开始指向的结点是第1个结点						
	p = L;						    //p指向第1个结点（注意：不是头结点）
	while (p != NULL && j < 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;									
}

④相比带头结点的单链表的ListInsert函数，无头结点的区别已在代码段中注释出来。

⑤此操作平均时间复杂度为O(n)。

3.指定结点后插

①InsertNextNode(LNode* p, ElemType e):在结点p后面插入元素e。

②代码实现：

#伪代码

bool InsertNextNode(LNode* p, int e)
{
	if (p == NULL)
		return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));    //要插入的新结点s
	if (s == NULL)					//某些情况下有可能会出现分配失败（如果内存不足）
		return false;
	s->data = e;                    //把e保存到s的数据域
	s->next = p->next;              //把插入位置后面的结点保存至新结点的指针域
	p->next = s;                    //把新插入结点保存至p的指针域，即将结点s连到p后面
	return true;
}

③时间复杂度O(1)。

④之前所提到的按位序插入操作中，在找到第i-1个结点后我们就可以直接用后插操作函数调用来简化按位序插入操作的函数了，如下：

4.指定结点前插

①InsertPriorNode(LNode* p, ElemType e) :在p结点之前插入元素e。

②代码实现：

#伪代码

bool InsertPriorNode(LNode* p, int e)
{
	if (p == NULL)
		return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)
		return false;
	s->next = p->next;					//将新的结点连到p之后
	p->next = s;						//将p连到s身上
	s->data = p->data;					//将s的数据域改写为p的数据域
	p->data = e;						//将p的数据域改写为e
	return true;
}

③时间复杂度O(n)。

四、删除操作（带头结点）

1.按位序删除

①ListDelete(&L,i,&e):删除操作，删除表L中第i个位置的元素，并用e返回删除元素的值。

②代码实现：

#伪代码

bool ListDelete(LinkList& L, int i, int& 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)		//当前p指向的是第i-1个结点，如果p.next为空的话，意味着第i位没有结点，就不能进行删除操作。
		return false;
	LNode* q = p->next;		    //p为第i-1位结点，p.next为第i位结点（即将被删除的结点），令q指向p.next
	e = q->data;						//用e来接收并返回即将删除结点的数据域的值
	p->next = q->next;					//将p连上被删除结点的后一个结点
	free(q);							//释放结点的存储空间
	return true;						//删除成功
}

③平均时间复杂度=O(n)。

2.指定结点的删除

①DeleteNode(LNode *p)：删除指定结点p。

②代码实现：

#伪代码

bool DeleteNode(LNode* p)
{
	if (p == NULL)
		return false;
	LNode* q = p->next;			//令q指向*p的后继结点
	p->data = p->next->data;	//把p的数据域改写为p的后继结点的数据域，即和后继结点交换数据域
	p->next = q->next;			//把*q结点从链中断开
	free(q);					//释放后继结点的存储空间,也就是留下替身p，放逐本身q
	return true;								
}

③时间复杂度O(1)。

④上面的方法只适用于p不是表尾结点，如果要删除表尾结点的话，根本找不到p.next.data，我们只能从表头开始依次寻找p的前驱，所以需采用另一种方法如下：

#伪代码

void DeleteTail(LNode* L)								
{
	if (L == NULL)
	{
		printf("链表空");
		return;
	}
	else
	{
		LNode* p;
		LNode* q;
		p = L->next;					//p=L->next指第一个结点
		q = L;							//q=L指头结点
		while (p->next != NULL)			//使p指向表尾结点，q指向表尾结点的前驱结点
		{
			p = p->next;
			q = q->next;
		}
		q->next = NULL;					//先改指向，使p断连，然后再free，以防表尾结点指向未知的结点而没有指向空

		free(p);
	}
}

五、查找操作（带头结点）

1.按位查找

①GetElem(L,i):获取表L中第i个位置的元素的值,返回第i个元素。

②代码实现：

#伪代码

LNode* GetElem(LinkList L, int i)
{
	if (i < 0)
		return NULL;
	LNode* p;
	int j = 0;
	p = L;
	while (p != NULL && j < i)					//循环找到第i个结点
	{
		p = p->next;
		j++;
	}
	return p;
}

③补充解释：上述代码段中注释那一行注意j<i,和前面找第i-1个结点不同，这里是直接找到第i个结点然后返回。

④平均时间复杂度=O(n)。

⑤这时，我们之前提到的按位插入和按位删除中寻找第i-1个结点的操作就可以封装为GetElem的函数调用，如下：

 

2.按值查找

①LocateElem(L,e):在表L中查找具有给定关键字值的元素,找到数据域==e的结点。

②代码实现：

#伪代码

LNode* LocateElem(LinkList L, int e)
{
	LNode* p = L->next;                    //p指向第一个结点
	while (p != NULL && p->data != e)      //依次向后对比查找
	{
		p = p->next;
	}
	return p;                              //找到后返回p，找不到返回NULL
}

③平均时间复杂度=O(n)。

④上面的函数形参查找的为int类型数据，如果是struct类型则不能直接比较p->data!=e，而应该将struct中的每个元素都进行对比。

六、求表长

①length(LinkList L)：返回单链表L的表长值。

②代码实现：

#伪代码

int length(LinkList L)
{
	int len = 0;                //返回值len
	LNode* p = L;
	while (p->next != NULL)     //依次向后查找，len++
	{
		p = p->next;
		len++;
	}
	return len;            
}

③平均时间复杂度=O(n)。

七、打印单链表

①printlist(LinkList L)：打印单链表L的内容。

②代码实现：

#伪代码

void printlist(LinkList L) 
{
	printf("该链表的内容为：");
	while (L->next != NULL)             
    {
		printf("%d ", L->next->data);
		L = L->next;
	}
	printf("\n");
}

八、单链表的建立

1.尾插法

①LinkList List_TailInsert(LinkList& L)。

②代码实现：

#伪代码

LinkList List_TailInsert(LinkList& L)				//正向建立单链表
{
	int x;											//设立elemtype为整型
	L = (LinkList)malloc(sizeof(LNode));			//建立头结点
	LNode* s, * r = L;								//定义指针r和s均指向L，实际上r是我们需要的表尾指针
	L->next = NULL;
	scanf("%d", &x);								//输入结点的值
	while (x != -1)									//-1判断循环结束，也可以写为其他的值
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;										//永远保证r指向新的表尾结点
		scanf("%d", &x);
	}		
	r->next	= NULL;									//尾结点指针置空
	return L;
}

③平均时间复杂度=O(n)。

④尾插法建立的单链表和用户输入的数据顺序相同，依次输入1，2，3，-1；所建立的单链表为1，2，3。

2.头插法

①LinkList List_HeadInsert(LinkList& L)。

②代码实现：

#伪代码

LinkList List_HeadInsert(LinkList& L)		    //逆向建立单链表
{
	LNode* s;
	int x;
	L = (LinkList)malloc(sizeof(LNode));		//创建头结点
	L->next = NULL;					//初始为空链表
	scanf("%d", &x);				//输入新的结点
	while (x != -1)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;				//把x赋值给新结点的数据域
		s->next = L->next;			//把新结点连到第1个结点上
		L->next = s;				//把头结点连接到新结点上，即完成将新结点插入表中，L为头指针
		scanf("%d", &x);
	}
	return L;
}

③平均时间复杂度=O(n)。

④头插法一个重要的应用就是链表的逆置，依次扫描链表的每一个结点，然后将每个结点用尾插法插入。

九、最后给出一种单链表逆置的方法，如下：

typedef struct LNode {
	int 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;
}

LinkList List_TailInsert(LinkList& L)				
{
	int x;											
	L = (LinkList)malloc(sizeof(LNode));			
	LNode* s, * r = L;								
	L->next = NULL;
	scanf("%d", &x);								
	while (x != -1)									
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;										
		scanf("%d", &x);
	}
	r->next = NULL;									
	return L;
}

void printlist(LinkList L) {
	printf("该链表的内容为：");
	while (L->next != NULL) {
		printf("%d ", L->next->data);
		L = L->next;
	}
	printf("\n");
}

int main()
{
	LNode* L = NULL;
	InitList(L);
	List_TailInsert(L);
	printlist(L);
	LNode* q = NULL;
	LNode* p = L->next;			
	L->next = NULL;			
	while (p)
	{
		q = p;
		p = p->next;
		q->next = L->next;
		L->next = q;
	}
	printlist(L);
}

代码解释：

1.定义单链表LNode;

2.所需用到的初始化、尾插法、打印函数和前文相同；

3.主函数部分：

①初始化L；

②用尾插法建立单链表，举例我们输入1，2，3，-1，建立的单链表为1，2，3；

③打印所建立的单链表；

④定义结点p、q,其中q置空，p指向第1个结点；

⑤将头结点置空，以便进行后续类似头插操作；

此时：

 

⑥while循环中：

第一次循环：

 

 

第二次循环：

 

 

 

第三次循环：

 

 

 

 

第四次循环时p判空，退出循环，观察我们得到的新的链表为：3，2，1。

最终代码调试结果：

 

 

炮炮轰
关注
  • 8
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表的插入操作（全）
Boyt1317的博客
05-04 2万+
单链表的插入（全） 三种方式进行插入操作
数据结构--单链表的插入&删除
m0_60593173的博客
06-27 6899
目标单链表的插入（位插、前插、后插）单链表的删除。
数据结构—线性表（四）单链表的基本操作
最新发布
qq_45356161的博客
06-13 246
主要介绍了单链表的插入和删除代码。
单链表的插入和删除
hibugs
07-07 5951
在上一篇文章（单链表的定义）中我们已经了解了单链表的含义和简单的实现。那么在这篇文章中，我们将要来讲解单链表的插入和删除操作。我们在上篇文章中已经讲解过，如果想要在表L中的第i个位置上插入指定元素e，我们需要找到第i-1的结点，在其后插入新的结点。大致步骤如下：当然当我们想在第一位插入新结点时，对于带头结点的链表的好处就是，在头部插入数据和其他任意一个位置插入数据的操作是一样的，非常方便。 代码分析（在第一个位置插入结点） 若 i = 1我们直接看函数的内部在进入时首先会判断，i的合法性（i小于1是不合法的
数据结构-单链表操作
有朋自远方来，不亦乐乎。
07-27 1245
注意步骤（2）（3）的顺序不能颠倒，否则会导致插入位置后的部分链表丢失。（2）将新结点的next指针指向插入位置后的结点。（3）将插入位置前的节点指针next指向新的结点。（2）手动释放掉结点，回收被结点占用的存储空间。插入位置一共分三种，分别是头部插入、中间插入和尾部插入。先找到目标位置再更改结点的数据域。（1）创建一个新的要插入的结点。（1）将结点从链表中摘下。...
单向链表的实现--插入
奋斗的菜鸟博客
06-11 1420
一、线性表链式存储结构的特点 用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。因此，为了表示每个数据元素ai与其直接后继数据元素ai+1之间的逻辑关系，对数据元素ai来说，除了存储其本身的信息之外，还需存储一个指示其直 接后继的信息（即直接后继的存储位置）。 这两部分信息组成数据元素ai的存储映像，称为结点 (node)。它包括两个域：其中存储数据元素信息的域称为数据域；存储直接后继存储位置的域称 为指针域。指针域中存储的信息称作指针或链。n个结点(a.....
单链表基本操作.rar
04-01
这个压缩包文件“单链表基本操作.rar”包含了一个名为“单链表基本操作.docx”的文档，我们可以从中学习到关于单链表的各种核心概念和操作。 单链表是由一系列节点构成的线性数据结构，每个节点包含两部分：数据域...
单链表基本操作
08-25
单链表 基本操作
基于Java实现的单链表基本操作之链表排.zip
04-26
在这个基于Java实现的单链表基本操作项目中，我们主要关注的是链表的排序。下面将详细讲解单链表的基本概念、Java中如何实现单链表以及如何进行链表排序。 **一、单链表的基本概念** 单链表是由一系列节点组成的...
基于Java实现的单链表基本操作之链表合并.zip
04-26
本项目聚焦于Java实现的单链表基本操作，特别是链表的合并这一关键操作。下面将详细介绍单链表的概念、基本操作以及如何在Java中实现链表合并。 单链表是一种线性数据结构，每个节点包含两部分：数据域，用于存储...
C语言数据结构（链表概念讲解和插入操作）
m0_49476241的博客
07-19 2793
本篇文章带大家正式的来学习数据结构，数据结构是学习操作系统，和深入C语言必不可少的，所以这篇文章开始带大家学习数据结构的知识。链表（Linked List）是一种常见的数据结构，用于存储和组织数据元素。它由一系列节点（Node）组成，每个节点包含存储的数据（或称为元素/值）以及指向下一个节点的引用（或链接/指针）。链表中的节点可以通过指针连接在一起，形成一个链式结构，而不像数组那样在内存中连续存储。每个节点只需要存储指向下一个节点的引用，而不需要预先分配固定大小的内存空间。
C语言实现链表的插入、删除、查询操作
猿长大人
05-08 1万+
前言本程序是数据结构上机实验内容，参考《数据结构（C语言版）》（清华大学出版社）中链表部分的伪代码实现。题目要求 设计链表结构体 建立一个链表，并录入n个原始数据 实现向链表中指定位置插入数据的功能 实现删除链表中指定位置的数据的功能 实现获取链表中指定位置的数据的功能 使用malloc函数动态分配内存地址 实例代码及说明#include <stdio.h> #include <stdlib.h>#
数据结构笔记 六：双链表
OnlyLove_的博客
10-14 337
说明：本笔记依照《王道论坛-数据结构》视频内容整理。 单链表：无法逆向检索，有时候不太方方便。 双链表：可进可退，存储密度更低一点。 一、双链表结点 typedef int ElemType; // 根据实际情况定义 typedef struct lNode{ // 定义单列表结点类型 ElemType data; // 每个结点存放一个数据元素 struct lNode *prior,*next; // prior指向前驱结点，
数据结构与算法（五）--链表概念以及向链表添加元素
学习不止境的博客
09-20 1126
今天我们学习另一种非常重要的线性数据结构–链表，之前我们已经学习了三种线性数据结构，分别是动态数组，栈和队列。其中队列我们额外学习了队列的另一种实现方式–循环队列。其实我们自己实现过前三个数据结构就知道，它们底层均依托静态数组，靠resize解决固定容量问题。而链表和前三种均不同，它是真正的动态数据结构。 学好链表，有利于： 就像火车一样，每一个节点就像一个个车厢，车厢除了人(数据)，还要和其他车厢进行连接，以使得数据是整合在一起的，用户可以方便的在所有的数据上进行查询等其他操作。而数据和数据之间的连接就是
数据结构之链表的插入（图文详解）
jayforever0715的博客
01-11 299
链表插入，图文详细解答
顺序表的插入、删除以及查找等基本操作的实现（C语言）
热门推荐
派拉斯兔子的博客
04-21 2万+
一、顺序表（顺序存储） （一）、定义（如何用代码实现） 线性表是具有相同数据类型的n（n >= 0）个数据元素的有限序列。 顺序表：用顺序存储的方式实现线性表顺序存储。 把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。 C语言 sizeof(ElemType)：知道一个数据元素大小。ElemType 就是你的顺序表中存放的数据元素类型. 基本操作的实现 1. 顺序表的实现——静态分配
【王道】数据结构与算法线性表(二)
Augenstern_QXL的博客
09-28 1048
✍、王道数据结构与算法线性表(二)
单链表基本操作的实现
09-29
单链表的基本操作包括单链表的初始化、判断空链表、销毁、清空以及求表长等操作。在单链表的初始化中，我们生成一个只有头指针的单链表，并将其指向的头结点的指针域置空。判断单链表是否为空表时，我们可以通过判断头结点的指针域是否为空来确定。 以下是单链表基本操作的实现代码： ```c /* 初始化链式线性表 */ Status IniList(LinkList *L) { *L = (LinkList)malloc(sizeof(Node)); /* 产生头结点，并使L指向此头结点 */ (*L)->next = NULL; /* 指针域为空 */ return OK; } /* 判断单链表是否为空表 */ Status IsEmpty(LinkList L) { return L->next == NULL ? OK : ERROR; } /* 销毁单链表 */ Status DestroyList(LinkList *L) { LinkList p, q; p = *L; while (p) { q = p->next; free(p); p = q; } *L = NULL; return OK; } /* 清空单链表 */ Status ClearList(LinkList L) { LinkList p, q; p = L->next; while (p) { q = p->next; free(p); p = q; } L->next = NULL; return OK; } /* 求单链表的长度 */ int Length(LinkList L) { int len = 0; LinkList p = L->next; while (p) { len++; p = p->next; } return len; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值