单链表（带头结点）（C/C++）

最新推荐文章于 2022-04-11 13:52:46 发布
最新推荐文章于 2022-04-11 13:52:46 发布
阅读量178 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41961380/article/details/119257197
版权

文章目录

0.创建单链表结点

//创建单链表结点
typedef struct LNode
{
	Elemtype data;
	struct LNode* next;
}LNode, * LinkList;

1.对单链表进行初始化

//对单链表进行初始化
bool InitList(LinkList& L)
{
	L = (LNode*)malloc(sizeof(LNode));
	if (L == NULL)
		return false;
	L->next = NULL;
	return true;
}

2.按位置查找元素

//按位置查找元素
LNode* GetElem(LinkList L, int i)
{
	if (i < 0)
		return NULL;
	LNode* p = L;
	int j = 0;
	while (p != NULL && j < i)
	{
		p = p->next;
		j++;
	}
	return p;
}

3.按值查找元素

//按值查找元素
LNode* LocateElem(LinkList L, Elemtype e)
{
	LNode* p = L->next;
	while (p != NULL && p->data != e)
	{
		p = p->next;
	}
	return p;
}

4.后插操作：在p结点之后插入元素e

//后插操作：在p结点之后插入元素e
Status 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; //将结点s连到p之后
	return true; //插入成功
}

5.前插操作：在p结点之前插入元素e

//前插操作：在p结点之前插入元素e (偷天换日迷之操作)
Status 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 连到 p 之后
	s->data = p->data; //将p中元素复制到s中
	p->data = e; //p中元素覆盖为e
	return true;
}

6.逆向建立单链表(头插法)

//逆向建立单链表(头插法)
LinkList List_HeadInsert(LinkList& L)
{
	LNode* s;
	Elemtype x;
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	scanf_s("%d", &x);
	while (x != 9999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		s->next = L->next;
		L->next = s;
		scanf_s("%d", &x);
	}
	return L;
}

7.正向建立单链表(尾插法)

//正向建立单链表(尾插法)
LinkList List_TailInsert(LinkList& L)
{
	int x; //设ElemType为整形
	L = (LinkList)malloc(sizeof(LNode)); //建立头结点
	LNode* s, * r = L; //r为表尾指针
	scanf_s("%d", &x);
	while (x != 9999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s; //在r结点之后插入元素x
		r = s; //r指向新的表尾结点
		scanf_s("%d", &x);
	}
	r->next = NULL;
	return L;
}

8.在第i个位置插入元素e

//在第i个位置插入元素e
Status ListInsert(LinkList& L, int i, Elemtype e)
{
	if (i < 1) //i的位置不合法
		return false;
	LNode* p = GetElem(L, i - 1);
	return InsertNextNode(p, e);
}

9.按位序删除

//按位序删除
Status ListDelete(LinkList& L, int i, Elemtype& e)
{
	if (i < 1)
		return false;
	LNode* p = GetElem(L, i - 1);
	if (p == NULL || p->next == NULL)
	{//第一个是判断是否合法，
	//第二个是第i-1个结点之后已无其他结点
		return false;
	}
	LNode* q = p->next; //令q指向被删除结点
	e = q->data; //用e返回被删除结点
	p->next = q->next; //将*q结点从链中"断开"
	free(q); //释放结点的存储空间
	return true; //删除成功
}

10.判断单链表是否为空

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

11.求表的长度

//求表的长度
int Length(LinkList L)
{
	int len = 0;
	LNode* p = L;
	while (p->next != NULL)
	{
		p = p->next;
		len++;
	}
	return len;
}

12.打印单链表

//打印单链表
void print(LinkList L)
{
	LNode* p = L->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
}

完整代码

//带头结点的单链表
#include<stdio.h>
#include<stdlib.h>

typedef int Elemtype;
typedef int Status;

//创建单链表结点
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;
}

//按位置查找元素
LNode* GetElem(LinkList L, int i)
{
	if (i < 0)
		return NULL;
	LNode* p = L;
	int j = 0;
	while (p != NULL && j < i)
	{
		p = p->next;
		j++;
	}
	return p;
}

//按值查找元素
LNode* LocateElem(LinkList L, Elemtype e)
{
	LNode* p = L->next;
	while (p != NULL && p->data != e)
	{
		p = p->next;
	}
	return p;
}

//后插操作：在p结点之后插入元素e
Status 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; //将结点s连到p之后
	return true; //插入成功
}

//前插操作：在p结点之前插入元素e (偷天换日迷之操作)
Status 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 连到 p 之后
	s->data = p->data; //将p中元素复制到s中
	p->data = e; //p中元素覆盖为e
	return true;
}

//逆向建立单链表(头插法)
LinkList List_HeadInsert(LinkList& L)
{
	LNode* s;
	Elemtype x;
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	scanf_s("%d", &x);
	while (x != 9999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		s->next = L->next;
		L->next = s;
		scanf_s("%d", &x);
	}
	return L;
}

//正向建立单链表(尾插法)
LinkList List_TailInsert(LinkList& L)
{
	int x; //设ElemType为整形
	L = (LinkList)malloc(sizeof(LNode)); //建立头结点
	LNode* s, * r = L; //r为表尾指针
	scanf_s("%d", &x);
	while (x != 9999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s; //在r结点之后插入元素x
		r = s; //r指向新的表尾结点
		scanf_s("%d", &x);
	}
	r->next = NULL;
	return L;
}

//在第i个位置插入元素e
Status ListInsert(LinkList& L, int i, Elemtype e)
{
	if (i < 1) //i的位置不合法
		return false;
	LNode* p = GetElem(L, i - 1);
	return InsertNextNode(p, e);
}

//按位序删除
Status ListDelete(LinkList& L, int i, Elemtype& e)
{
	if (i < 1)
		return false;
	LNode* p = GetElem(L, i - 1);
	if (p == NULL || p->next == NULL)
	{//第一个是判断是否合法，
	//第二个是第i-1个结点之后已无其他结点
		return false;
	}
	LNode* q = p->next; //令q指向被删除结点
	e = q->data; //用e返回被删除结点
	p->next = q->next; //将*q结点从链中"断开"
	free(q); //释放结点的存储空间
	return true; //删除成功
}

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

//求表的长度
int Length(LinkList L)
{
	int len = 0;
	LNode* p = L;
	while (p->next != NULL)
	{
		p = p->next;
		len++;
	}
	return len;
}
//打印单链表
void print(LinkList L)
{
	LNode* p = L->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
}

int main()
{
	LinkList L;
	InitList(L);
	List_TailInsert(L);
	Elemtype e;
	printf("此单链表的长度为：%d\n", Length(L));
	printf("此链表中第3个元素的值为:%d\n", GetElem(L, 3)->data);
	ListDelete(L, 3, e);
	printf("此链表中第3个元素的值为:%d\n", GetElem(L, 3)->data);

	if (LocateElem(L, 6))
	{
		printf("此链表中存在元素6\n");
	}
	else
	{
		printf("此链表中不存在元素6\n");
	}
	InsertPriorNode(GetElem(L, 1), 99);
	InsertNextNode(GetElem(L, 1), 66);
	print(L);
	return 0;
}

测试用例：34 12 45 43 89 6 76 9999
测试结果：
此单链表的长度为：7
此链表中第3个元素的值为:45
此链表中第3个元素的值为:43
此链表中存在元素6
99 66 34 12 43 89 6 76

chenmoan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现单链表：带头结点
weixin_44915226的博客
06-17 325
基本功能 初始化单链表 建立单链表：头插法和尾插法 遍历单链表 按位序查找元素 按值查找元素 按位序插入结点 按位序删除结点 求单链表长度   代码 #include <iostream> #include <stdlib.h> using namespace std; typedef int ElemType; //定义单链表结点 typedef struct LNode{ ElemType data; struct LNode *next; }LNode
C/C++语言实现单链表（带头结点）
weixin_33777877的博客
02-22 653
彻底理解链表中为何使用二级指针或者一级指针的引用 数据结构之链表-链表实现及常用操作(C++篇) 　　C语言实现单链表，主要功能为空链表创建，链表初始化（头插法），链表元素读取，按位置插入，（有序链表）按值插入，按位置删除，按值删除，清空链表，销毁链表。 　　关键思路：（1）将结点创建结构体；（2）链表中添加头结点，以便统一操作；（3）使用结点一级指针和二级指针的异同点；（4）链表的...
C++ 单链表（无头结点）
qq_43650934的博客
11-17 5035
文章目录总结归纳代码实现 总结归纳 头结点可以没有，头指针必须有。访问整个链表，是用过遍历头指针来进行的。 这里没有特别的设置一个头指针，因为当指针指向整个链表 L 时，该指针的实现效果就是头指针。 不带头结点的单链表，即单链表的第一个结点就存储数据，头指针也指向第一个结点；带头结点的单链表，第一个结点是头结点，不存储数据，从头结点的 next 开始存储，头指针可以从头结点的 next 开始遍历。 对于结点的前插操作，找到对应位置的结点，设新结点为该节点的后继结点，将该结点的 data 后移至新结点的 d
C++单链表的创建（有头结点）
Moon_yao的博客
03-26 2372
c++单链表的创建（有头结点）
数据结构基础-C/C++实现单链表（带头结点）
qq_42908756的博客
04-11 1796
定义结构体 /** * @brief 链表节点 */ typedef struct LinkedNode{ // 存储数据 int data; // 下一个节点的地址 LinkedNode *next; }LinkedNode, *LinkedList; 初始化 /** * @brief 初始化一个带头结点的单链表 * * @return LinkedList 单链表的头节点 */ LinkedList initLinkedListHaveHead() { // .
C++之链表中头指针、头节点、首元结点的
爱编程的小屁孩的博客
09-21 2966
头指针：顾名思义是一个指针，指向链表的开始地址； 头结点：第一个节点，该节点只有地址信息，改地址指向下一个结点，数据域无信息； 首元结点：含第一个元素的结点，为链表的实际开始位置，数据域包含第一个数据信息，指针指向下一个结点。 为什么设有头结点，为的是插入删除方便，每次删除，只需phead-&gt;next=phead-&gt;next-&gt;next;若无头结点，删除的话，不好处理。 若还是不...
数据结构与算法 c++实现 //删除顺序递增表中的重复元素 //对单链表实现就地逆置 //删除递增单链表中的重复元素
06-04
本篇文章将深入探讨在C++中实现数据结构，特别是顺序表和单链表的操作，以及如何处理它们的重复元素和逆序问题。 1. **顺序表**：顺序表是一种简单的数据结构，它的元素存储在一块连续的内存空间中，通过数组的形式...
带头结点单链表操作C++的实现
04-07
使用C++面向对象的方法实现带头结点的单链表的插入,删除等基本操作.
单链表（带头结点）.cpp
08-01
实现单链表及其一些基本操作函数（带头结点） 1.头文件包含 2.宏定义及节点类型描述 3.初始化、判断是否为空 4.指定位置插入操作 5.在p节点后插入元素e 6.在p节点前插入元素e 7.删除操作：删除第i个节点，元素...
c++实现 不带头结点单链表基本操作
11-24
下面将详细解释如何用C++实现不带头结点单链表的基本操作，包括逆序建立链表、插入元素以及删除元素。 首先，我们需要定义链表节点的结构体，如下： ```cpp struct ListNode { int data; ListNode* next; }; ```...
数据结构 不带头结点的单链表代码
12-16
在这个主题中，我们重点关注不带头结点的单链表，以及如何用C++来实现它的遍历、插入、查询和删除功能。 首先，不带头结点的单链表意味着链表的第一个元素就是链表本身，没有额外的节点用于标识链表的起始位置。这...
C++实现带头结点单链表
adminlpx的博客
10-29 2034
单链表属于基本数据结构中的线性结构，它应用于很多数据结构中，例如栈，队列等，作用广泛。在数据结构中我们习惯把关于单链表的一系列操作制作为一个ADT(Abstract Data Type)使用，在C++中把它封装为一个类，使用起来更是方便。 关于单链表的操作包括插入（包括头插和尾插）、删除、查找、检查是否有环、环的长度、环的入口等操作。以下就是我的代码实现： 每个结点的数据类型应该是一个结构体类
C++单链表的建立（有头节点）
Jeff_Winger的博客
10-22 6092
#ifndef chainWithHeader_ #define chainWithHeader_ #include #include //数组 #include //STL中的算法 #include //istringstream流 #include//异常处理 #include//迭代器 #include//标准库中的数学操作函数 #include #include #include
带有附加头节点的单链表C++实现
Billy1900的博客
04-24 2100
定义linearlist基类// // Created by lenovo on 2018/4/22. // #ifndef LINKNODE_LINEARLIST_H #define LINKNODE_LINEARLIST_H template&lt;class T&gt; class linearlist{ public: linearlist(); ~linearlist...
链式队列（不带头结点 )(C/C++）
沉默安的博客
08-19 1906
文章目录0.定义链式队列的基本结构1.初始化链式队列(不带头结点)2.判断队列是为空（不带头结点）3.入队(不带头结点)4.出队（不带头结点）完整代码 0.定义链式队列的基本结构 /*0.定义链式队列的基本结构*/ typedef struct LinkNode { //链式队列结点 ElemType data; struct LinkNode* next; }LinkNode; typedef struct { //链式队列 LinkNode* front, * rear; //队列的队头和队尾指
链栈（不带头结点）（C/C++）
沉默安的博客
08-15 1311
文章目录0.链栈的数据结构定义1.链栈的初始化2.进栈3.出栈4.读取栈顶元素5.判空全部代码 0.链栈的数据结构定义 /*0.链栈的数据结构定义*/ typedef struct LinkNode { ElemType data; struct LinkNode* next; }LinkNode, * LinkStack; 1.链栈的初始化 /*1.链栈的初始化*/ void InitStack(LinkStack& S) { S = NULL; //将头指针指向NULL } 2.进栈
单链表（无头结点）（C/C++）
沉默安的博客
08-04 1134
带头结点与不带头结点的单链表，在进行操作时有哪些区别呢？ 当对单链表的表首元素进行删除或插入操作时，要进行区别处理，无头结点的单链表进行头指针的更新。 带头结点的单链表，无论单链表是否为空链表，头指针都指向头结点。不带头结点的单链表，当单链表为非空链表时，头指针指向链表第一个结点(LNode)，当单链表为空链表时，头指针指向空（NULL）。 //不带头结点的链表 #include<stdio.h> #include<stdlib.h> typedef int Elemtype;
顺序队列（C/C++）
沉默安的博客
08-18 882
文章目录一般队列0.定义队列的基本结构1.初始化队列2.判断队列空3.入队4.出队顺序队列的完整代码循环队列0.定义循环队列的基本结构1.初始化队列2.判断队列空3.入队4.出队循环队列的完整代码 一般队列 0.定义队列的基本结构 /*0.定义队列的基本结构*/ typedef struct { ElemType data[Maxsize]; //用静态数组存放队列元素 int front, rear; //队头指针与队尾指针 }SqQueue; 1.初始化队列 /*1.初始化队列*/ void In
用C++语言创建一个带头结点的单链表,输出显示所创建单链表各结点的 值
最新发布
05-05
好的，以下是用C语言创建带头结点的单链表并输出各结点的值的代码： ```c #include #include // 定义单链表结构体 typedef struct Node { int data; // 存储结点的数据 struct Node *next; // 存储下一个结点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值