单链表中有头结点 & 无头结点的各种基本操作(完整代码)

最新推荐文章于 2024-04-21 21:17:15 发布
最新推荐文章于 2024-04-21 21:17:15 发布
阅读量2.9k 收藏 64
点赞数 14
分类专栏： 计算机技术 文章标签： 数据结构 单链表 算法 c语言 visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42071236/article/details/119088123
版权

基础薄弱，理解尚浅，若有错误，欢迎指正。
线性表-单链表(Ⅲ)

单链表中有头结点 & 无头结点的各种基本操作(完整代码)

有头结点

#include<stdio.h>
#include<malloc.h> //用malloc函数开辟新单元时需用此头文件
typedef int ElemType;
typedef struct LNode //定义单链表结点类型
{
	ElemType data; //数据域
	struct LNode *next; //指针域
}LNode, * LinkList;

void InitList(LinkList &L) //初始化线性表
{
	L = (LNode *)malloc(sizeof(LNode)); //创建头结点
	L->next = NULL; //其next域置为NULL
}

bool ListEmpty(LinkList &L)  //判断线性表是否为空表
{
	return(L->next == NULL); //C语言中返回0或1，C++中返回true或false
}

void HeadInsert(LinkList &L) //逆向建立单链表(头插法)
{
	LNode *s;
	int num;
	printf("输入：");
	scanf("%d", &num);
	while(num!=999)
	{
		s = (LNode *)malloc(sizeof(LNode));
		s->data = num; //为数据域赋值
		s->next = L->next;
		L->next = s;
		scanf("%d", &num);
	}
}

void TailInsert(LinkList& L) //正向建立单链表(尾插法)
{
	LNode* s, * p = L;
	int num;
	printf("输入：");
	scanf("%d", &num);
	while(num!=999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = num; //为数据域赋值
		s->next = p->next;
		p->next = s;
		p = p->next;
		scanf("%d", &num);
	}
}

void DispList(LinkList &L) //输出线性表
{
	LNode *p = L->next; //p指向首结点
	while (p != NULL)
	{
		printf("%d ", p->data); //输出p结点的data域
		p = p->next; //p移向下一个结点
	}
}

int ListLength(LinkList &L) //求线性表的长度
{
int n = 0; //n用来计数，初始为0
	LNode * p = L->next; //p指向首结点
	while (p != NULL) //当p的指针域不为NULL时循环
	{
		n++; //计数值+1
		p = p->next; //p移向下一个结点
	}
	return n;
}

bool GetElem(LinkList &L, int i, ElemType &e) //求线性表中的某个数据元素值
{
	LNode *p = L; //p指向头结点，j置0(即头结点的序号为0)
	int j = 0;
	if (i <= 0) return false; //i错误返回假
	while (p != NULL && j < i)
	{
		j++;
		p = p->next; //p移向下一个结点
	}
	if (p == NULL) return false; //不存在第i个数据结点，返回false
	else //存在第i个数据结点，返回true
	{
		e = p->data;
		return true;
	}
}
 
bool LocateElem(LinkList &L, ElemType e) //按元素值查找
{
	LNode *p = L->next; //p指向首结点，i置为i(即首结点的序号为1)
	ElemType i = 1;
	while (p != NULL && p->data != e) //查找data值为e的结点，其序号为i
	{
		p = p->next; //p移向下一个结点
		i++;
	}
	if (p == NULL) return 0; //不存在值为e的结点，返回0
	else return i; //存在值为e的结点，返回其逻辑序号i
}

bool ListInsert(LinkList L, int i, ElemType e) //插入数据元素
{
	LNode *p = L, *s; //p指向头结点，j置为0(即头结点的序号为0)
	int j = 0;
	if (i <= 0) return false; //i错误返回false
	while (p != NULL && j < i - 1) //查找第i-1个节点
	{
		j++;
		p = p->next; //p移向下一个结点
	}
	if (p == NULL) //未找到第i-1个结点，返回false
		return false;
	else //找到第i-1个结点p，插入新结点并返回true
	{
		s = (LNode *)malloc(sizeof(LNode));
		s->data = e; //创建新结点s，其data域置为e
		s->next = p->next;		
		p->next = s; //将结点s插入到结点p之后
		return true; //返回true表示成功插入第i个节点
	}
}

bool ListDelete(LinkList &L, int i, ElemType &e) //删除数据元素
{
	LNode *p = L, *q; //p指向头结点，j置为0(即头结点的序号为0)
	int j = 0;
	if (i <= 0) return false; //i错误返回false
	while (p != NULL && j < i - 1) //查找第i-1个节点
	{
		j++;
		p = p->next; //p移向下一个结点
	}
	if (p == NULL) return false; //未找到第i-1个结点，返回false
	else //找到第i-1个结点p
	{
		q = p->next; //q指向第i个结点
		if (q == NULL) //若不存在第i个结点，返回false
			return false;
		e = q->data;
		p->next = q->next; //从单链表中删除q结点
		free(q); //释放q结点
		return true; //返回true表示成功删除第i个节点
	}
}

void DestoryList(LinkList &L) //销毁单链表
{
	LNode* pre = L, * p = L->next; //pre指向结点p的前驱结点
	while (p != NULL) //扫描单链表L
	{
		free(pre); //释放free结点 
		pre = p; //pre、p同步后移一个结点
		p = pre->next;
	}
	free(pre); //循环结束时，p为NULL，pre指向尾结点，释放它
}

int main()
{
	LinkList L;

	InitList(L); //初始化线性表,创建一个空的单链表
	printf("现在是空链吗：%d\n\n", ListEmpty(L)); //返回1则表示当前线性表为空

	HeadInsert(L); //调用函数，头插法创建单链表
	printf("现在是空链吗：%d\n\n", ListEmpty(L));

	LNode *p = L;
	printf("输出线性表中的值：");
	DispList(L); //调用函数，输出单链表
	printf("\n\n");

	printf("建立的线性表的长度为：%d\n\n", ListLength(L)); //调用函数，接收返回的线性表长度

	int num;
	printf("该位置的值为：%d\n查找成功了吗？：%d\n\n", num, GetElem(L, 4, num));
	//调用函数，判断单链表L中有没有第i个数据结点，如果有则返回该值

	
	printf("第一个与该值相等的逻辑序号为：%d\n\n",LocateElem(L, 3));
	//调用函数，在单链表L中从头开始找第一个值域与e相等的结点，如果有则返回逻辑序号
	
	printf("向某个位置插入一个元素，插入成功了吗？：%d\n",ListInsert(L, 3, 4)); 
	printf("插入后线性表的长度为：%d\n", ListLength(L));
	printf("输出插入后线性表中的值：");
	DispList(L);
	printf("\n\n");

	ElemType e;
	printf("删除某个位置的元素，删除成功了吗？：%d\n",ListDelete(L, 2, e));
	printf("删除的元素值为：%d\n", e);
	printf("删除后线性表的长度为：%d\n", ListLength(L));
	printf("输出删除后线性表中的值：");
	DispList(L);
	printf("\n\n");

	DestoryList(L); //销毁线性表
	return 0;
}

程序分析：

  • 强调这是一个链表——使用LinkList；
  • 强调这是一个结点——使用LNode *；
  • 运行结果：
    在这里插入图片描述

无头结点

#include<iostream>
using namespace std;
#include<malloc.h> //用malloc函数开辟新单元时需用此头文件
typedef int ElemType;
typedef struct LNode //定义单链表结点类型
{
	ElemType data; //数据域
	struct LNode *next; //指针域
}LNode, * LinkList;

bool ListEmpty(LinkList &L)  //判断线性表是否为空表
{
	return(L == NULL); 
}

void InitList(LinkList &L) //初始化线性表
{
	L  = NULL; 
}

void HeadInsert(LinkList &L) //逆向建立单链表
{
	LNode *s;
	int i;
	int num;
	printf("输入：");
	scanf("%d", &num);
	while(num!=999)
	{
		s = (LNode *)malloc(sizeof(LNode));  //创建新结点
		s->data = num;
		if (L == NULL)
		{
			L = s;
			s->next = NULL;
		}
		else
		{
			s->next = L;
			L = s;
		}
		scanf("%d", &num);
	}
}

void TailInsert(LinkList& L) //正向建立单链表
{
	LNode* s, * p;
	int num;
	printf("输入：");
	scanf("%d", &num);
	while(num!=999)
	{
		s = (LNode*)malloc(sizeof(LNode));  //创建新结点
		s->data = num;
		if (L == NULL)
		{
			L = s;
			s->next = NULL;
			p = L;
		}
		else
		{
			s->next = p->next;
			p->next = s;
			p = p->next;
		}
		scanf("%d", &num);
	}
}

void DispList(LinkList &L) //输出线性表
{
	LNode *p = L; //p指向首结点
	while (p != NULL)
	{
		cout<<p->data<<' '; //输出p结点的data域
		p = p->next; //p移向下一个结点
	}
}

int ListLength(LinkList& L) //求线性表的长度
{
int n = 0; //n用来计数，初始为0
	LNode * p = L; //p指向首结点
	while (p != NULL) 
	{
		n++; //计数值+1
		p = p->next; //p移向下一个结点
	}
	return n;
}

bool GetElem(LinkList &L, int i, ElemType &e) //求线性表中的某个数据元素值
{
	LNode* p = L; //p指向头结点
	int j = 1; //j置1(即头结点的序号为1)
	if (i <= 0) return false; //i错误返回假
	while (p != NULL && j < i)
	{
		j++;
		p = p->next; //p移向下一个结点
	}
	if (p == NULL) return false; //不存在第i个数据结点，返回false
	else //存在第i个数据结点，返回true
	{
		e = p->data;
		return true;
	}
}
 
bool LocateElem(LinkList &L, ElemType e) //按元素值查找
{
	LNode *p = L; //p指向首结点
	int i = 1; //i置为i(即首结点的序号为1)
	while (p != NULL && p->data != e) //查找data值为e的结点，其序号为i
	{	
		i++;
		p = p->next; //p移向下一个结点
	}
	if (p == NULL) return 0; //不存在值为e的结点，返回0
	else return i; //存在值为e的结点，返回其逻辑序号i
}

bool ListInsert(LinkList &L, int i, ElemType e) //插入数据元素
{
	LNode *p = L, *s; //p指向头结点
	int j = 1; //j置为1(即头结点的序号为1)
	if (i <= 0) return false; //i错误返回false
	while (p != NULL && j < i - 1) //查找第i-1个节点
	{
		j++;
		p = p->next; //p移向下一个结点
	}
	if (p == NULL) //未找到第i-1个结点，返回false
		return false;
	else //找到第i-1个结点p，插入新结点并返回true
	{
		s = (LNode *)malloc(sizeof(LNode));
		s->data = e; //创建新结点s，其data域置为e
		if (i == 1)
		{
			s->next = L;
			L = s;
		}
		else
		{
			s->next = p->next;
			p->next = s;
		}//将结点s插入到结点p之后
		return true; //返回true表示成功插入第i个节点
	}
}

bool ListDelete(LinkList &L, int i, ElemType &e) //删除数据元素
{
	LNode *p = L, *q; 
	int j = 1; //p指向头结点，j置为1(即头结点的序号为1)
	if (i <= 0) return false; //i错误返回false
	while (p != NULL && j < i - 1) //查找第i-1个节点
	{
		j++;
		p = p->next; //p移向下一个结点
	}
	if (p == NULL) return false; //未找到第i-1个结点，返回false
	else //找到第i-1个结点p
	{
		if (i == 1)
		{
			e = p->data;
			L = p->next;
			free(p);
			return true;
		}
		else 
		{
			q = p->next; //q指向第i个结点
			if (q == NULL) //若不存在第i个结点，返回false
				return false;
			e = q->data;
			p->next = q->next; //从单链表中删除q结点
			free(q); //释放q结点
			return true; //返回true表示成功删除第i个节点
		}
	}
}

void DestoryList(LinkList &L) //销毁线性表
{
	LNode* pre = L, * p = L->next; //pre指向结点p的前驱结点
	while (p != NULL) //扫描单链表L
	{
		free(pre); //释放free结点 
		pre = p; //pre、p同步后移一个结点
		p = pre->next;
	}
	free(pre); //循环结束时，p为NULL，pre指向尾结点，释放它
}

int main()
{
	LinkList L;
	InitList(L); //初始化线性表,创建一个空的单链表
	cout<<"现在是空链吗？-"<<' ' <<boolalpha<< ListEmpty(L) << endl; //返回true则表示当前线性表为空
	
	HeadInsert(L); //调用函数，头插法创建单链表
	cout << "现在是空链吗？-" << ' ' << boolalpha << ListEmpty(L) << endl;
	LNode * p=L;
	printf("输出线性表中的值：");
	DispList(L); //调用函数，输出单链表
	printf("\n\n");

	printf("建立的线性表的长度为：%d\n\n", ListLength(L)); //调用函数，接收返回的线性表长度

	int num;
	cout << "查找成功了吗？- " << boolalpha << GetElem(L, 6, num)<<endl;
	printf("该位置的值为：", num);
	printf("\n");
	//调用函数，判断单链表L中有没有第i个数据结点，如果有则返回该值

	printf("第一个与该值相等的逻辑序号为：%d\n\n",LocateElem(L, 7));
	//调用函数，在单链表L中从头开始找第一个值域与e相等的结点，如果有则返回逻辑序号
	
	cout<<"向某个位置插入一个元素，插入成功了吗？-"<<boolalpha<<ListInsert(L, 1, 6)<<endl; 
	printf("插入后线性表的长度为：%d\n", ListLength(L));
	printf("输出插入后线性表中的值：");
	DispList(L);
	printf("\n\n");

	ElemType e;
	cout<<"删除某个位置的元素，删除成功了吗？："<<boolalpha<<ListDelete(L, 1, e)<<endl;
	printf("删除的元素值为：%d\n", e);
	printf("删除后线性表的长度为：%d\n", ListLength(L));
	printf("输出删除后线性表中的值：");
	DispList(L);
	printf("\n\n");

	DestoryList(L); //销毁线性表
	
	return 0;
}

程序分析：

  • 从有头结点的运行结果可以看到，当函数返回值类型为bool时，C语言中只能用1代表true，用0代表false。因此在无头结点的这段程序里，有些行采用了C++的cout输出，因为C++可以使bool类型返回true或false，只需要加上"boolalpha"即可。
  • ！有头结点和无头结点的一些函数中，循环条件要先写"p != NULL"，因为如果p=NULL了，逻辑与操作就不会再继续执行后面的操作了，此时说明链表已经遍历结束了，整个链表中没有找到该值，此时应返回false。
    在这里插入图片描述

有头结点和无头结点的对比

-有表头结点和无表头结点单链表的区别为：指向不同、数据域不同、简洁性不同。

  • 指向不同
    1、有表头结点单链表：头指针指向头结点。
    2、无表头结点单链表：头指针指向第一个首元结点。
  • 数据域不同
    1、有表头结点单链表：数据域可以不设任何信息，也可以记录表长等信息。
    2、无表头结点单链表：数据域可以不存任何信息。
  • 简洁性不同
    1、有表头结点单链表：减少了单链表添加、删除时特殊情况的判断，减少了程序的复杂性。
    2、无表头结点单链表：删除或添加时都得需要判断一次首元结点。
—Miss. Z—
关注
  • 14
    点赞
  • 踩
  • 64
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
单循环链表（带头结点和不带头结点）
05-21
自己在实验课是做的。主要是单循环链表，有带头结点和不带头结点两种情况。 文件里分别进行了实现。有两个文件
数据结构（2）—单链表（带头结点和不带头结点）
qq_61914039的博客
08-31 2990
单链表是通过一组任意的存储单元来存储线性表中的数据元素。每个结点都有data数据域（用来存放数据元素）和next指针域（用来存放后继节点的地址）。对于顺序表，单链表可以解决顺序表需要一整个大量的连续的存储单元的缺点，单链表的元素可以离散地分布在存储空间中，即非随机存取的存储结构，不能直接找到表中某个特定的结点，当查找某个特定的结点时，需要从表头开始一个一个遍历。因为单链表附加了指针域，缺点就是存储空间增大。单链表有带头结点和不带头结点两种类型。引入头结点。
链表的基本操作-创建一个链表
最新发布
Y2663438690的博客
04-21 477
在这里描述函数接口。例如：在这里解释接口参数。在函数中输入m，及m行数据，完成链表的创建。该函数利用scanf从输入中获取学生的信息，并将其组织成单向链表。int num;/*学号*//*姓名*/int score;/*成绩*//*指向下个结点的指针*/单向链表的头尾指针保存在全局变量head和tail中。输入为若干个学生的信息（学号、姓名、成绩），当输入学号为0时结束。
诙谐友好版——1.2.有(无)头结点的单链表，实现增删改查，头尾中间插，3.完整版包含主函数及运行范例
bug_caicai的博客
04-16 170
文章目录1.主函数以及头插输入，特定位置插入信息，输出1.定义结点2.有头结点的单链表，初始化,创造旗帜（因为指针域为空，暂时不是人）3。头插法4.输出5。特定位置有中间，头，尾主函数2.插入（头插，特定位置插，尾插），删除查找（采用找朋友插队诙谐的代码解释，但请不要随意插队哦）1.中间插2.头插3.尾插，4.删除5.查找7.统计节点3.完整代码及易错点标注~尾插 ​ 1.主函数以及头插输入，特定位置插入信息，输出 1.定义结点 #include<stdio.h> #include<str
C语言——链表（带头节点与不带头节点）
m0_73771309的博客
07-18 1245
链表是一种常见的线性数据结构，它由一系列的节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点可以在内存中不连续地分布，通过指针将它们串联在一起。下面呢，进入正题！！！首先呢，我们先看这张图！这是带头节点，带头节点的链表是在链表头部添加了一个额外的节点，该节点不存储任何数据，只是作为链表的起始位置。带头节点的链表中，头节点的下一个节点才是实际存储数据的第一个节点。
数据结构不带头节点跟带头节点的单链表区别，C语言代码展示
maojiaoliang的博客
04-25 2363
单链表头插法 不带头结点 void FronttList1(List *L) { List p; ElemType x; printf_s("请输入一组数据，以‘0’为结束符\n"); scanf_s("%d", &x); *L = NULL; while (x) { p = (List)malloc(sizeof(Lnode)); p->data = x; p->next = *L; *L = p; scanf_s("%d", &x); .
C++之创建链表带头节点、不带头节点
云霄IT的博客
02-23 1165
【代码】C++之创建链表带头节点、不带头节点。
无头结点的单链表的c算法的实现
11-02
无头结点的单链表在C语言中的实现是一个基础且重要的数据结构操作。单链表是一种线性数据结构，由一系列元素（节点）组成，每个元素包含数据和指向下一个元素的指针。无头结点的单链表指的是链表的结构不包括一个...
无头节点的单链表
07-17
无头节点单链表的实现可是说是对C语言指针一个最直接、最贴合实际、也是最具有归纳性的程序设计应用。许多C语言基础面试题都涉及单链表的实现和构造，其目的就是考察面试者对C语言基础数据类型是否有足够的了解，对...
数据结构 不带头结点的单链表代码
12-16
这与带头结点的链表不同，后者通常有一个特殊的头结点，用于存储链表的相关信息，并指向第一个元素。在不带头结点的链表中，我们通常需要通过指针来追踪链表的头部。 单链表的基本结构由一系列节点组成，每个节点...
单链表的两种简单实现（有头节点和无头节点）
12-09
在本文中，我们将深入探讨单链表的两种简单实现：有头节点和无头节点。这两种方法虽然看似微小的区别，但在实际编程中可能会产生显著的影响。 首先，我们来理解链表的基本概念。链表不像数组那样在内存中连续存储...
算法分析_有无头结点的单链表的逆序和插入排序问题集源码微软面试题总结
07-16
本文将深入探讨标题和描述中提到的两个关键概念：有无头结点的单链表的逆序以及插入排序，这些都是在面试中，尤其是像微软这样的顶级科技公司面试时常见的问题。 首先，我们来理解单链表的概念。单链表是一种线性...
C语言实现链栈的基本操作
m0_73171073的博客
10-10 1990
这里介绍不带头节点来实现链栈 由于在链栈实现过程中需要对header指针指向的位置不断更改时header指针一直指向栈顶因此这里会用到二级指针
顺序表和链表03——带头单链表
m0_61608447的博客
04-22 1176
用java语言写 带头 的单链表 前言： 抛出问题： 我们之前写单链表的时候，一直要考虑头节点的注意事项，贼烦人！无论是插入还是删除，都得考虑这个头节点，就是因为头结点没有前驱。 解决办法： 那么现在就引入一个 虚拟头节点的概念： dummyHead（相当于现实中的火车头），只作为链表的头结点使用，不存储有效数值。 目的： 这样做以后，链表中的其他有效结点全都可以一视同仁，都具有 前驱节点 了。 实现： 1.单链表的每个节点-车厢类 /** * 单..
实参形参与指针5——无头结点循环链表与带头结点循环链表
weixin_42224065的博客
10-17 1774
虽然C语言的指针偏向底层，不利于上手和大型项目开发（某些），但是用C去实现链表基本操作是有利于我们的代码功底的。而且在实现的过程中，实现远比理解要复杂困难的多，尤其是循环链表，当你实现过就会发现，为啥你的大学老师总是劝你要带头结点了。
565-约瑟夫环问题(无头节点的单向循环链表)
LINZEYU666的博客
09-16 2483
约瑟夫环问题(无头节点的单向循环链表) 我们采用无头节点的单向循环链表解决约瑟夫环问题 假设k=1 , m=3 图中的1个数字代表着1个节点 我们采用双指针，初始化均指向第一个有效节点 因为单链表删除节点，用双指针方便 我们用p专门用来指向要删除的节点 q专门用来指向要删除的节点的前一个节点 但是现在比较尴尬的是，它没有头节点，所以一开始只能指向第一个有效节点 k=1的话，它们本身就在第一个元素上，从第一个元素开始报数，报道第3个， 现在我们要删除3这个节点，3出列。 然后p指向的是4节点，从1开始报
【数据结构与算法】 - (不带头结点)单链表详细实现思路及代码(C/C++语言)
wkd_007的博客
03-26 5746
文章先介绍 “头结点” 在链表的作用，以及 “有头结点” 和 “无头结点” 的区别，然后再详细介绍了“无头结点链表” 的实现步骤，最后给出了 “无头结点单链表” 的C语言实现代码，同时也给出了 “有头结点单链表” 的C语言实现代码。读者可以对比这两份代码，将会对单链表的“头结点”有非常深刻的理解。
无头结点单链表的特点、增删改查及逆置
m0_63188530的博客
11-28 975
首先建立一个结构体： typedef struct node { int a; char b; struct node* next; //定义一个指向本结构体类型的指针类型 }Node,*LinkList; //Node是结构体类型，是struct node的别名， LinkList是结构体指针类型，LinkList head相当于 Node* head，也相当于struct node* head 一. 增 （1）尾插
删除无头指针的单链表中的一个节点
qq_37719621的博客
01-11 577
设一个没有头结点指针的单链表,有一指针指向此单链表中一个结点（非第一个，也非最后一个结点），将该结点从单链表中删除，要求时间复杂度O（1）。 没有头指针，则不可能遍历该单链表，况且要求时间复杂度为是常数，则可交换要删除节点（p）和该节点的下一个节点(p->next)的数据域，然后问题转换为删除p节点的下一个节点。 q=p->next; p->data=q->data; p-...
理解链表逻辑结构：头结点与无头结点的区别
**区别**：无头结点的链表在操作时需要从第一个节点开始遍历，而有头结点的链表可以直接通过头指针访问任何位置，更便于操作。无头结点的链表插入和删除节点时可能需要移动更多节点，效率较低；而有头结点的链表在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值