带头结点的链表的基本操作(超详细）

已于 2022-06-01 16:20:57 修改
阅读量4.6k 收藏 112
点赞数 22
文章标签： 链表 数据结构 c++
于 2022-06-01 16:15:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53679998/article/details/125084329
版权

前言

本文参考王卓老师的数据结构视频和严蔚敏老师的《数据结构》

一、链表的定义

用一组地址任意的存储单元存放线性表中的数据元素。

结点 = 数据元素+指针(指后继元素存储位置)

二、链表的 C 语言描述

代码如下（示例）：

//带头结点的单链表
typedef struct LNode {
    int data;
    struct LNode* next;
}Lnode,*LinkList;

三、链表中基本操作的实现

3.1构造一个带头结点的空链表

c++中用new来动态的开辟空间，而c中则是用malloc来开辟空间

我使用new来动态开辟空间

注意:参数是引用型的

代码如下(示例): 

void InitList(LinkList& L)
{
	L = new Lnode;//L=(LinkList)malloc(sizeof(LNode))
	L->next = NULL;
}

3.2取第i个数据元素

结束条件：链表走到空或者i的大小不对，比1小

则while语句判断条件为：while(p&&j<i)   p表示当前节点不为空，j<i表示传进来的i是正确的，并且到该点

当此时p为空或者j>i，则返回0，表示未找到

否则把此时节点的data传给引用型参数data，并返回1

代码如下(示例): 

int GetElem_L(LinkList L, int i, int& data)
{
	int j = 1;
	Lnode* p;
	p = L->next;
	while (p && j < i)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i)	return 0;
	data = p->data;
	return 1;
}

3.3在链表中查找值为e的元素

时间效率分析：查找次数与位置有关，O(n)

注意，可以按照具体情况来写函数的返回值类型

比如，返回值类型可以是节点的地址，也可以是节点的位置

3.3.1返回值类型是节点的地址

代码如下(示例):

Lnode* LocationElem(LinkList L, int e)
{
	Lnode* p = L->next;
	while (p && p->data != e)
	{
		p = p->next;
	}
	return p;
}

3.3.2返回值类型是节点的位置(序号)

代码如下(示例):

int LocateElem_L(LinkList L, int e)
{
	int j = 1;
	Lnode* p = L->next;
	while (p && p->data != e)
	{
		p = p->next;
		j++;
	}
	if (p)	return j;
	else return 0;
}

3.4在第i位插入数据元素

修改指针的时间O(1),但是不知道插在哪里，所以需要查找，查找时间O(n)

代码如下(示例): 

void ListInsert_L(LinkList& L, int i, int e)
{
	int j = 0;
	Lnode* p = L;
	while (p && j < i - 1)//即找到i-1的位置
	{
		p = p->next;
		j++;
	}
	if (!p || j > i - 1)
	{
		printf("i值错误,i小于1或大于表长\n");
		return;
	}
	Lnode* s = new Lnode;
	s->data = e;
	s->next = NULL;
	s->next = p->next;
	p->next = s;//注意两行不能调换位置，否则s指向自己，错误
	printf("插入成功\n");
}

 3.5删除第i个数据元素

修改指针的时间O(1),但是不知道删除位置，所以需要查找，查找时间O(n)

代码如下(示例): 

void ListDelete(LinkList& L, int i, int& e)
{
	Lnode* p = L,*q;
	int j = 0;
	while (p->next && j < i - 1)//找到i-1的节点
	{
		p = p->next;
		j++;
	}
	if (!(p->next) || j > i - 1)
	{
		printf("未找到要删除的节点\n");
		return;
	}
	q = p->next;
	e = q->data;
	p->next = q->next;
	delete q;//释放空间
	printf("成功删除\n");
}

 3.6 前插建立具有n的元素链表

时间复杂度：O(n)  

逆序输入

确保结果与想要的是一致的（与尾插结果一致）

代码如下(示例): 

void CreateList_F(LinkList& L, int t[],int n)
{
	//创建n个节点
	L = new Lnode;
	L->next = NULL;
	for(int i=n-1;i>=0;i--)
	{
		Lnode* p =new Lnode;
		p->data=t[i];
		p->next = L->next;
		L->next = p;
	}
}

3.7尾插建立具有n的元素链表

正序输入

时间复杂度：O(n)

代码如下(示例):

void CreateList_L(LinkList& L,int a[],int n)
{
	//尾指针指向尾节点
	L = new Lnode;
	L->next = NULL;
	Lnode* r = L;//尾指针，开始也指向头节点
	for (int i = 0; i < n; i++)
	{
		Lnode* p = new Lnode;
		p->data=a[i];
		p->next = NULL;
		r->next = p;
		r = p;//把尾指针更新到新节点的位置
	}
}

3.8线性表置空

从首元节点开始删除，保存了头指针和头节点

头节点的next赋值为空

 代码如下(示例):

void CleanList(LinkList& L)
{
	Lnode* p = L->next;
	Lnode* q;
	while (p)
	{
		q = p->next;
		delete p;
		p = q;
	}
	L->next = NULL;
}

3.9销毁链表

所有节点，包括头节点也删掉

 代码如下(示例): 

void DestoryList(LinkList& L)
{
	Lnode* p;
	while (L)
	{
		p = L;
		L = L->next;
		delete p;
	}
}

3.10判断链表是否为空

头节点和头指针还在算空表，返回1

当头节点的next值不为空，即起码有个首元节点，则不算空表，返回0

 代码如下(示例):  

int isEmpty(LinkList L)
{
	if (L->next == NULL)
		return 1;
	return 0;
}

 3.11求链表的表长

用一个int型的length来计算，在循环中，当tmp未走到空的时候，每次都加1

 代码如下(示例):  

int ListLength(LinkList L)
{
	Lnode* tmp = L->next;
	int length = 0;
	while (tmp != NULL)
	{
		length++;
		tmp = tmp->next;
	}
	return length;
}

 3.12遍历链表

当链表未走到空的时候，依次把所有节点的数据都输出

代码如下(示例):  

void ListTraverse(LinkList L)
{
	Lnode *tmp=L->next;
	int i=0;
	while(tmp!=NULL)
	{
		cout<<"第"<<i+1<<"个元素的数据:"<<tmp->data<<endl; 
		i++;
		tmp=tmp->next;
	}
}

四、链表代码实现

代码如下(示例):  

#include <iostream>
using namespace std;
const int N=101;
//带头结点的单链表
typedef struct LNode {
	int data;
	struct LNode* next;
}Lnode,*LinkList;
//链表初始化
//构造一个带头结点的空链表
void InitList(LinkList& L)
{
	L = new Lnode;//L=(LinkList)malloc(sizeof(LNode))
	L->next = NULL;
}
//判断链表是否为空
//头节点和头指针还在（空表）
int isEmpty(LinkList L)
{
	if (L->next == NULL)
		return 1;
	return 0;
}
//销毁链表
//所有节点，包括头节点也删掉
void DestoryList(LinkList& L)
{
	Lnode* p;
	while (L)
	{
		p = L;
		L = L->next;
		delete p;
	}
}
//清空单链表
//清空元素,从首元节点开始删除
void CleanList(LinkList& L)
{
	Lnode* p = L->next;
	Lnode* q;
	while (p)
	{
		q = p->next;
		delete p;
		p = q;
	}
	L->next = NULL;
}
//求链表的表长
int ListLength(LinkList L)
{
	Lnode* tmp = L->next;
	int length = 0;
	while (tmp != NULL)
	{
		length++;
		tmp = tmp->next;
	}
	return length;
}
//求第i个元素的值
int GetElem_L(LinkList L, int i, int& data)
{
	int j = 1;
	Lnode* p;
	p = L->next;
	while (p && j < i)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i)	return 0;
	data = p->data;
	return 1;
}
//按值查找  返回地址
//时间效率分析：查找次数与位置有关，O(n)
Lnode* LocationElem(LinkList L, int e)
{
	Lnode* p = L->next;
	while (p && p->data != e)
	{
		p = p->next;
	}
	return p;
}
//按值查找，返回位置序号
int LocateElem_L(LinkList L, int e)
{
	int j = 1;
	Lnode* p = L->next;
	while (p && p->data != e)
	{
		p = p->next;
		j++;
	}
	if (p)	return j;
	else return 0;
}
//在第i个元素之前插入值为e的节点
//修改指针的时间O(1),但是不知道插在哪里，所以需要查找，查找时间O(n)
void ListInsert_L(LinkList& L, int i, int e)
{
	int j = 0;
	Lnode* p = L;
	while (p && j < i - 1)//即找到i-1的位置
	{
		p = p->next;
		j++;
	}
	if (!p || j > i - 1)
	{
		printf("i值错误,i小于1或大于表长\n");
		return;
	}
	Lnode* s = new Lnode;
	s->data = e;
	s->next = NULL;
	s->next = p->next;
	p->next = s;//注意两行不能调换位置，否则s指向自己，错误
	printf("插入成功\n");
}
//删除  删除第i个节点
//修改指针的时间O(1),但是不知道删除位置，所以需要查找，查找时间O(n)
void ListDelete(LinkList& L, int i, int& e)
{
	Lnode* p = L,*q;
	int j = 0;
	while (p->next && j < i - 1)//找到i-1的节点
	{
		p = p->next;
		j++;
	}
	if (!(p->next) || j > i - 1)
	{
		printf("未找到要删除的节点\n");
		return;
	}
	q = p->next;
	e = q->data;
	p->next = q->next;
	delete q;//释放空间
	printf("成功删除\n");
}
//头插法建立单链表   时间复杂度：O(n)  逆序输入
void CreateList_F(LinkList& L, int t[],int n)
{
	//创建n个节点
	L = new Lnode;
	L->next = NULL;
	for(int i=n-1;i>=0;i--)
	{
		Lnode* p =new Lnode;
		p->data=t[i];
		p->next = L->next;
		L->next = p;
	}
}
//尾插法  正序输入 时间复杂度：O(n)
void CreateList_L(LinkList& L,int a[],int n)
{
	//尾指针指向尾节点
	L = new Lnode;
	L->next = NULL;
	Lnode* r = L;//尾指针，开始也指向头节点
	for (int i = 0; i < n; i++)
	{
		Lnode* p = new Lnode;
		p->data=a[i];
		p->next = NULL;
		r->next = p;
		r = p;//把尾指针更新到新节点的位置
	}
}
//遍历 
void ListTraverse(LinkList L)
{
	Lnode *tmp=L->next;
	int i=0;
	while(tmp!=NULL)
	{
		cout<<"第"<<i+1<<"个元素的数据:"<<tmp->data<<endl; 
		i++;
		tmp=tmp->next;
	}
}
void menu()
{
	cout<<"*******************************************"<<endl;
	cout<<"1.构造一个带头结点的空链表 "<<endl;
	cout<<"2.建立具有n的元素链表"<<endl;
	cout<<"3.取第i个数据元素"<<endl;
	cout<<"4.在链表中查找值为e的元素"<<endl;
	cout<<"5.在第i位插入数据元素"<<endl;
	cout<<"6.删除第i个数据元素"<<endl;
	cout<<"7.求链表的表长"<<endl;
	cout<<"8.判断链表是否为空"<<endl;
	cout<<"9.清空链表"<<endl;
	cout<<"10.销毁链表"<<endl;
	cout<<"11.遍历链表"<<endl;
	cout<<"12.退出"<<endl;
	cout<<"*******************************************"<<endl;
}
int main()
{
	int choice;
	LinkList L;
	int i2,e2,e,i1,e1;
	int t,n,x1;
	int x,data;
	while(1)
	{
		menu();
		cout<<"请输入你的选择"<<endl;
		cin>>choice;
		switch(choice)
		{
			case 1:
				InitList(L);
				cout<<"成功初始化"<<endl;
				break;
			case 2:
				cout<<"请选择你想要创建链表的方法"<<endl;
				cout<<"1.是头插法\t2.是尾插法"<<endl;
				cin>>t;
				if(t==1)
				{
					int a1[N];
					cout<<"请输入需要多少个节点"<<endl;
					cin>>n;
					for(int i=0;i<n;i++)
					{
						cout<<"请输入第"<<i+1<<"个节点的数据"<<endl;
						cin>>a1[i];	
					} 
					CreateList_F(L,a1,n);
				}
				else
				{
					int a2[N];
					cout<<"请输入需要多少个节点"<<endl;
					cin>>n;
					for(int i=0;i<n;i++)
					{
						cout<<"请输入第"<<i+1<<"个节点的数据"<<endl;
						cin>>a2[i];	
					} 
					CreateList_L(L,a2,n);
				}
				break;
			case 3:	
				cout<<"输入要查找的位置"<<endl;
				cin>>x; 
				GetElem_L(L,x,data);
				cout<<"第"<<x+1<<"个元素的值为："<<data<<endl;
				break;
			case 4:
				cout<<"输入值"<<endl;
				cin>>e;
				x1=LocateElem_L(L,e);
				cout<<"位置为："<<x1<<endl;
				break;
			case 5:
				cout<<"请输入要插入哪里跟节点的数据"<<endl;
				cin>>i1>>e1;
				ListInsert_L(L,i1,e1);
				break;
			case 6:
				cout<<"请输入要删除哪个节点"<<endl;
				cin>>i2;
				ListDelete(L,i2,e2);
				cout<<"删除成功，原来的节点的数据为"<<e2<<endl;
				break;
			case 7:
				cout<<"长度为"<<ListLength(L)<<endl;
				break;
			case 8:
				if(isEmpty(L)) cout<<"链表为空"<<endl;
				else cout<<"链表不为空"<<endl;
				break;
			case 9:
				CleanList(L);
				cout<<"清空成功"<<endl;
				break;
			case 10:
				DestoryList(L);
				cout<<"销毁成功"<<endl; 
				break; 
			case 11:
				ListTraverse(L);
				break;
			case 12:
				cout<<"成功退出"<<endl;
				exit(0);
			default:
				cout<<"请重新输入"<<endl; 
				break;
		}	
	}
}

五、测试结果 

测试样例：创建4个节点    数据分别为1、2、3、4        其余测试基于以上4个节点

 图一

图二

 

图三

图四

 

图五

图六

图七

 

图八

 

 图九

图十

 

图11

图十二 

六、总结

        链表是一种动态分配空间的存储结构，能更有效地利用存储空间，通过对单链表基本操作的代码实现，我深刻领悟到以“指针”指示元素的后继，在插入或删除元素时不需要移动元素。但是与此同时，由于链表是“顺序存取”的结构，给随机存取元素和在表尾插入等操作带来不便。，所以接下来我将学习尾指针表示的单链表，双向链表以及循环链表等。

waggghhhh
关注
  • 22
    点赞
  • 踩
  • 112
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
6-6 带头结点的链式表操作集 (20分)
qq_45798109的博客
09-21 1752
本题要求实现带头结点的链式表操作集。 函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中List结构定义如下： typedef struct LNode *PtrToLNode; struct LNode { ElementType Data;
PTA 复习 6-6 带头结点的链式表操作集 (知识点总结)
weixin_44640697的博客
12-19 640
PTA 复习 6-6 带头结点的链式表操作集 本题要求实现带头结点的链式表操作集。 文章目录PTA 复习 6-6 带头结点的链式表操作集本题要求实现带头结点的链式表操作集。函数接口定义：裁判测试程序样例：输入样例：输出样例：解题代码：一、细节分析：二、知识点总结：1、有表头和没有表头的的区别：链表的基础知识：需要注意的情况：带有头结点遍历输出数据时`while (Head->Next != NULL)`不带有头结点的链表输出数据时`while (Head != NULL)`2
【数据结构】——单链表的基本操作（带头结点）
weixin_51398574的博客
07-01 3747
1.在单链表的定义中不能省略结构体名称LNode（第2行中）。原因：在该结构体内部使用到了该结构体类型去定义next指针域。2.第5行中的重命名LNode和*LinkList的意义：//将结构体重命名为LNode//将结构体的指针重命名为LinkList。
6-6 带头结点的链式表操作集
LEO的博客
07-15 866
代码】6-6带头结点的链式表操作集。
【PTA】带头结点的链队列的基本操作 (10 分)
karshey的博客
04-08 1631
裁判测试程序样例： #include <stdio.h> #include<malloc.h> #define OK 1 #define ERROR 0 typedef int Status; typedef int ElemType; typedef struct LNode { ElemType data; struct LNode * next; }LNode,*LinkList; typedef struct { LinkList front,.
带头结点的单向链表的基本操作的实验代码和实验报告
04-14
使用给定数据结构，实现带头结点的单向链表的创建、删除链表、插入结点等操作，每个学生的学号互不相同，学号不同而姓名相同则为不同的学生，每个学生的学号在合并后的链表中不重复，如果出现重复，则删除年龄较小...
C语言实现带头结点的链表的创建、查找、插入、删除操作
01-20
本文实例讲述了C语言实现带头结点的链表的创建、查找、插入、删除操作。是数据结构中链表部分的基础操作。分享给大家供大家参考。具体方法如下： #include #include typedef struct node { int data; struct ...
带头结点链表的各种操作（c语言）
10-26
/*尾插法创建一个带头结点链表*/ node *creat(node *head) { node *r,*s; int x; r=head; printf("在新链表中输入数据以0结束:"); scanf("%d",&x); while(x) { s=(node*)malloc(sizeof(node)); s->data=...
C语言实现带头结点尾结点的双向非循环链表的基本操作
最新发布
10-09
C语言实现带头结点尾结点的双向非循环链表的基本操作 C语言实现带头结点尾结点的双向非循环链表的基本操作 C语言实现带头结点尾结点的双向非循环链表的基本操作
6-1 带头结点的链式表操作集 (20分)
green_hand11的博客
03-28 3414
6-1 带头结点的链式表操作集 (20分)* **本题要求实现带头结点的链式表操作集。 函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中...
数据结构 - 链表 - 头节点的意义
qazw9600的专栏
08-12 9364
说明 初学数据结构时，对于链表定义一个空数据的头结点表示不理解，不明白其作用，甚至有时为了节省内存空间而去掉该节点，但是头结点是有意义的。 头结点示意图： 缺点 多定义了一个结点，多占用了一个结点的内存。 改善方式：可以采用linux kernel中的list实现方式（结点中只包含结点指针不包含结点数据），减少头节点的内存占用。 优点 单链表或双链表删除或插入节点时，如果没有头结点，处理有两种情况： 操作的对象是第一个结点，相对于其它情况，需要额外更改链表入口指针。 操作的对象不是第一个结
链表（带头结点）
weixin_46481053的博客
07-08 1080
注意:强调这是一个单链表——用LinkList 强调这是一个结点——用LNode * 2.按位序插入(找到前驱然后插入) 4.指定结点前插 5.按位序删除 6.指定结点删除 //删除最后一个结点不适用，会有空指针 9.头插法建表 10.尾插法建表 11.链表逆置 1.头插法第二轮循环的过程如下图注意：q = p; //意思是把p的地址赋给q，即把q挪到p的位置，但是要注意p的位置并未改变 二.双链表 1.定义和初始化 头结点的pri
带头结点单链表 (详解)
热门推荐
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
11-02 1万+
结构体后的*List是一个指向结构体的指针类型，我们通过它来定义该类型的指针。如：List p ; 则这个p就是指向LinkedList结构体的一个指针，也就是单链表的头指针。（所以说头指针是必然存在的，但单链表不一定有头结点，注意区分头指针和头结点）
链表
kguazju的博客
04-30 653
Add Two Polynomials欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出...
数据结构—带头结点的单链表
weixin_68908154的博客
02-15 1959
带头结点的单链表结构设计、接口函数设计、接口函数实现
【数据结构与算法】(6)：带头结点的双向循环链表
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
05-31 2243
带头结点的双向循环链表
单链表的整表创建（头结点版）
qq_61832249的博客
03-30 3643
*****参照《大话数据结构》整理***** 一、基本要素概念明析 1.指针 指针也就是内存地址 ，指针变量是用来存放内存地址的变量（按照百度定义，进行下面的介绍） 2.结构体 结构体是C语言中一种重要的数据类型，该数据类型由一组称为成员（或称为域，或称为元素）的不同数据组成，其中每个成员可以具有不同的类型。结构体通常用来表示类型不同但是又相关的若干数据。 3.结点 一个包括数据域与指针域的结构体 4.头指针 为了方便此处将头指针理解为头指针变量（虽然与1好像有矛盾） 5.头节点 链.
【链表】单链表：带表头结点
请赐予我力量
04-28 2591
写在前面的话： 版权声明：本文为博主原创文章，转载请注明出处！ 博主是一个小菜鸟，并且非常玻璃心！如果文中有什么问题，请友好地指出来，博主查证后会进行更正，啾咪~~ 每篇文章都是博主现阶段的理解，如果理解的更深入的话，博主会不定时更新文章。 本文最后更新时间：2020.4.28 头指针与头结点 我们把链表中第一个结点的存储位置叫做头指针，那么整个链表的存取必定从头指针开始进行。但有时，我们...
while (p && j < i) { p = p->next; j++; }
weixin_35755188的博客
01-03 385
这是一个条件循环语句的语法。其中，p是一个布尔表达式，只有在p为真时，循环体中的语句才会被执行。在这个条件循环中，只要p为真，就会不断循环执行循环体中的语句。 例如： while (i < 10) { i++; // other statements } 在这个例子中，变量i的值会不断增加，直到它大于等于10为止。在这之前，循环体中的其他语句会不断被执行。 ...
带头结点链表和不带头结点链表的区别
03-28
带头结点链表和不带头结点链表的主要区别在于是否存在一个额外的头结点。带头结点链表在实现时会增加一个额外的头结点，该头结点不存储任何数据，其作用是方便链表的操作和处理空链表的情况。而不带头结点链表则没有这个额外的头结点，链表的头指针指向的是第一个存储数据的结点。 带头结点链表的优点在于可以简化链表的操作，例如插入、删除、查找等操作都可以统一处理，不需要特殊考虑空链表的情况。而不带头结点链表则需要特殊处理空链表的情况。另外，带头结点链表的实现也比不带头结点链表更加简单和清晰。 不带头结点链表的优点在于可以节省一个额外的结点的空间，特别是在链表结点较少的情况下，这个优势会更加明显。另外，一些算法和数据结构的实现中可能会要求使用不带头结点的链表，例如链表的快速排序算法就需要使用不带头结点的链表实现。 综合来看，带头结点链表和不带头结点链表各有优缺点，具体应该根据具体情况选择使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值