王道数据结构代码实现(单链表)

已于 2023-05-09 16:36:49 修改
阅读量353 收藏 6
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 链表 c++
于 2023-04-25 22:57:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64008087/article/details/130376034
版权

带头结点

#include <iostream>
#include <stdlib.h>

//定义单链表结点类型
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;
}

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

//判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L, LNode* p)
{
	return p->next == NULL;
}

//正向建立单链表,尾插法
LinkList List_TailInsert(LinkList& L)
{
	int x;
	L = (LinkList)malloc(sizeof(LNode));//建立头结点
	if (L)
	{
		LNode* s, * r = L;		//r为表尾指针
		std::cin >> x;			//输入结点的值
		while (x != -1)			//输入-1表示结束
		{
			s = (LNode*)malloc(sizeof(LNode));
			if (s)
			{
				s->data = x;
				r->next = s;	//在r结点之后插入元素x
				r = s;			//r指向新的表尾结点,永远指向最后一个结点
				std::cin >> x;
			}
		}
		r->next = NULL;		//尾结点指针置空
	}
	return L;
}

//逆向建立单链表,头插法;重要应用: 链表的逆置
LinkList List_HeadInsert(LinkList& L)
{
	LNode* s;
	int x;
	L = (LNode*)malloc(sizeof(LNode));
	if (L)
	{
		L->next = NULL;
		std::cin >> x;
		while (x != -1)
		{
			s = (LNode*)malloc(sizeof(LNode));
			if (s)
			{
				s->data = x;
				s->next = L->next;
				L->next = s;
				std::cin >> x;
			}
		}
	}
	return L;
}

//指定结点的后插操作
bool InsertNextNode(LNode* p, int e)
{
	if (p == NULL)
		return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)		//内存分配失败
		return false;
	s->data = e;		//用结点 s 保存数据元素 e
	s->next = p->next;
	p->next = s;		//将结点 s 连接到 p 之后
	return true;
}

//按位查找,返回第i个元素(带头结点)
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)//循环找到
	{
		p = p->next;
		j++;
	}
	return p;
}

//前插操作: 在 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->next = s;			//新结点 s 连到 p 之后
	s->data = p->data;		//将 p 中元素复制到 s 中
	p->data = e;			//p 中元素覆盖为 e
	return true;
}

//在第 i 个位置上插入元素 e
bool ListInsert(LinkList& L, int i, int e)
{
	if (i < 1)
		return false;
	LNode* p = GetElem(L, i - 1);//找到第i-1个结点
	return InsertNextNode(p, e);
}

//在第i个位置上删除当前节点,并返回被删除的值
bool ListDelete(LinkList& L, int i, int& e)
{
	if (i < 1)
		return false;
	LNode* p = GetElem(L, i - 1);//找到i-1个结点
	if (p == NULL)
		return false;
	if (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;
}

//删除指定结点 p,如果p是最后一个结点的话,只能从表头开始依次寻找p的前驱.
bool DeleteNode(LNode* p)
{
	if (p == NULL&&p->next==NULL)
		return false;
	LNode* q = p->next;			//令q指向*p的后继结点
	p->data = p->next->data;	//和后继结点交换数据域
	p->next = q->next;			//将*q结点从链中"断开"
	free(q);					//释放后继结点的存储空间
	return  true;

}

//按值查找,找到数据域==e的结点
LNode* LocateElem(LinkList L, int e)
{
	LNode* p = L->next;
	//从第1个结点开始查找数据域为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;
}
int main()
{
	LinkList L;			//声明一个指向单链表的指针
	return 0;
}

不带头结点

#include <iostream>
#include <stdlib.h>
using namespace std;

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

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

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

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

//按位查找,返回第i个元素
LNode* GetElem(LinkList L, int i)
{
	if (i < 0)
		return NULL;
	LNode* p;		//指针p指向当前扫描到的结点
	int j = 1;		//当前p指向的是第几个结点
	p = L;			//p指向第1个结点
	while (p != NULL && j < i)//循环找到第i个结点
	{
		p = p->next;
		j++;
	}
	return p;
}

//按值查找
LNode* LocateElem(LinkList L, int e)
{
	LNode* p = L;
	while (p != NULL && p->data != e)
		p = p->next;
	return p;	//找到后返回该结点指针,否则返回NULL
}

//指定结点的后插操作
bool InsertNextNode(LNode* p, int e)
{
	if (p == NULL)
		return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)		//内存分配失败
		return false;
	s->data = e;		//用结点s保存数据元素e
	s->next = p->next;
	p->next = s;		//将结点s连到p之后
	return true;
}

//指定结点的前插操作
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->next = s;		//新结点s连到p之后
	s->data = p->data;	//将p中元素复制到s中
	p->data = e;		//p中元素覆盖为e
	return true;
}

//按位插入
bool ListInsert(LinkList& L, int i, int e)
{
	if (i < 1)
		return false;
	if (i == 1)	//插入第1个结点的操作与其他结点操作不同
	{
		LNode* s = (LNode*)malloc(sizeof(LNode));
		if (s == NULL)
			return false;
		s->data = e;
		s->next = L;
		L = s;	//头指针指向新结点
		return true;
	}
	return InsertNextNode(GetElem(L, i - 1), e);
}

//按位序删除
bool ListDelete(LinkList& L, int i, int& e)
{
	if (i < 1)
		return false;
	if (i == 1)	//i=1,特殊处理
	{
		if (L == NULL)	//空表
			return false;
		LNode* q = L;	//指向第1个结点
		e = q->data;	//返回删除的值
		L = q->next;	//L等于q指向的结点的next值,也就是指向下一个结点
		free(q);		//释放结点的存储空间
		return true;
	}
	LNode* p;	//指针p指向当前扫描到的结点
	int j = 1;	//当前p指向的是第几个结点
	p = L;		//p指向第1个结点
	p = GetElem(L, i - 1);
	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;	//将*q结点从链中“断开”
	free(q);			//释放结点的空间
	return true;
}

//指定结点的删除
bool DeleteNode(LNode* p)
{
	if (p == NULL)
		return false;
	LNode* q = p->next;		//令q指向*p的后继结点
	p->data = p->next->data;//和后继结点交换数据域
	p->next = q->next;		//将*q结点从链中“断开”
	free(q);				//释放后继结点的存储空间
	return true;
}

//正向建立单链表
LinkList List_TailInsert(LinkList& L)
{
	int x;
	L = NULL;		//空表
	std::cin >> x;	//输入结点的值
	if (x != -1)	//读入-1则输入停止
	{
		LNode* s, * r = L;	//r为表尾指针
		s = (LNode*)malloc(sizeof(LNode));//先插入第一个结点
		if (s == NULL)
			return L;
		s->data = x;//第一个结点插入元素x
		L = s;		//L指向第一个结点
		r = s;		//r指向第一个结点
		cin >> x;
		while (x != -1)
		{
			s = (LNode*)malloc(sizeof(LNode));
			if (s == NULL)
				return L;
			s->data = x;	
			r->next = s;	//在r结点之后插入元素x
			r = s;			//永远保持r指向最后一个结点
			cin >> x;
		}
		r->next = NULL;		//尾结点指针置空
	}
	return L;
}

int main()
{
	LinkList L;
	InitList(L);		//测试
	//ListInsert(L, 1, 6);
	//ListInsert(L, 2, 7);
	int a = 0;
	//cout << ListDelete(L, 2, a) << " " << a << endl;//由于不带头结点,测试是否能正确删除.
	//cout << GetElem(L, 2) << endl;	
	//cout<<LocateElem(L, 7)<< endl;
	//cout << Length(L) << endl;
	//List_TailInsert(L);
	return 0;
}

m0_64008087
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2023王道数据结构-单链表基本操作的实现代码（C++版）
qq_45961676的博客
05-10 1220
王道数据结构单链表基本操作
王道数据结构实践代码----单链表的实现（C语言版）
繁臻的小窝
08-26 3627
王道数据结构实践代码----单链表的实现（C语言版） 前言 日期：2021年8月26日 书籍：王道2021年数据结构考研复习指导 代码内容：实现单链表的实现，包括初始化，插入新元素，删除新元素，输出，查询 代码难点 1.C语言的指针和C++的引用转换 … 指针我太阳你个** 简而言之,王道书上的单链表声明和初始化是以C++为模板的,C语言无法直接使用,需要做一定的转换,介于我指针学的也不是很好,就不说这中间的转换过程和原理了,日后有闲暇了再慢慢研究 2.头插法和尾插法的区别,带头指针和不带头指针的区别
【椰羊加工厂】王道2024数据结构代码实现--单链表
DNApifa的博客
05-06 175
欢迎阅读文章！准备101012单链表。
王道数据结构代码题（C语言） 单链表部分
Cerulea_n的博客
06-13 234
单链表实现 #include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 typedef struct Node { int data; struct Node* next; }Node; Node* initList() { // 创建单链表 Node* L = (Node*)malloc(sizeof(Node)); L -> data =
【数据结构】【王道】【线性表】单链表的实现及基本操作（带头结点）（可直接运行）
treesorshining的博客
07-11 1771
1.2 初始化 1.3 判空 1.4 按位序插入 1.5 指定结点后插操作 1.6 指定结点前插操作 1.7 按位序删除 1.8 按位查找 1.9 按值查找 1.10 表的长度 1.11 单链表建立（尾插法） 1.12 单链表建立（头插法） 1.13 输出所有链表元素 2.完整代码 3.运行截图............
王道考研408 | 数据结构 | 单链表实验代码
lijiamingccc的博客
10-16 1327
目录1.初始化单链表带头节点的单链表初始化不带头节点的单链表初始化2.按位查找3.按值查找4.计算单链表长度5.插入操作后插操作前插操作结合插入和查找6.删除节点7.建立链表头插法建立链表尾插法建立链表tip：定义一个输出链表的函数主程序测试运行结果： 所有代码均经过测试，附运行截图 1.初始化单链表 带头节点的单链表初始化 bool Init_HeadList(LinkList& L) { L = (LNode* )malloc(sizeof(LNode));//分配一个头节点 if (!L)
王道代码题汇总（持续更新）
m0_49218627的博客
06-28 1458
主要用于复习
王道数据结构使用C语言编写代码时的纰漏（一）——单链表的代码初始化，头插法代码以及运行
weixin_51341256的博客
05-09 357
这两个操作的对象都应该是指针的地址，因为指针本身是存放所指向元素a1的地址的，所指向元素a1的地址是指针的值，而指针的地址才是我们想要的。linkList是Node *类型，也就是一级指针，我们常用到的头指针，&linkList 使用取地址符&，获取头指针的地址，这不就是二级指针的值所希望的一级指针的地址吗？头插法传入参数我使用了二级指针更清晰表达，其效果等同于LinkList *L，由于引入二级指针，所以需要慎重留意带指针的部分，分清楚它到底是存的谁的值（就是上一级指针的地址对吧，牢牢抓住这一点）。
王道数据结构C语言单链表基本操作实现
m0_57180439的博客
09-14 345
本文介绍了C语言实现单链表的各项基本操作
王道数据结构精简笔记——单链表
weixin_53830825的博客
07-10 414
/ 定义单链表结点类型（结点） ElemType data;// 每个结点存放一个数据元素（数据域） struct LNode * next;// 指针指向下一个结点（指针域） } LNode , * LinkList;// LinkList是指向结构体首地址的指针使用LinkList：强调这是一个单链表；使用LNode *：强调这是一个结点；
L=(Linklist)malloc(sizeof(Node))含义
热门推荐
weixin_41845265的博客
08-16 1万+
sizeof函数计算数据（包bai括数组、变量、du类型、结构体等）所占内存空间，用zhi字节数表示。 malloc函数用于在内存开辟了一段地址，而这段地址的首地址存在返回的那个指针变量里，由于不知道到底这段地址有多长，可以存什么变量，所以它的类型是空的，你可以强制类型转换，使其变成确定长度，固定存放一种数据类型的地址，而不管它是哪种类型，其首地址还是原来那个，还是存在一个指针变量中，指针变量就是放指针的嘛，指针是一个地址，指针变量是一个我们定义的，用来放那个地址的变量。 那么代码的意思就是说 获取Node
单链表的建立之头插法和尾插法
斑驳的岁月
07-16 356
1. 尾插法 void List_TailInsert(LinkList &L,ElemType a[],int n){ LNode *s,*r; //s指向新申请的结点，r指向L的最后一个结点 int i; L = (LNode *)malloc(sizeof(LNode)); L->next = NULL; r = L; //r一开始指向头结点 for(i=0;i<n;i++){ s = (LNode *)malloc(sizeof(LNode)); //s指向
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1031
可以参考以下视频。
数组算法--基本查找
2303_78660417的博客
07-20 291
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 222
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
数据结构第32节 无锁编程
hummhumm的专栏
07-17 851
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
C语言排序算法
最新发布
m0_49476241的博客
07-21 714
本篇文章带大家来学习C语言的基本算法。本篇文章主要为大家讲解了C语言中的排序算法，在笔试面试当中可能会经常考察到这些排序算法。
数据结构——栈
weixin_45942515的博客
07-19 247
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1084
24暑假刷题day15打卡 二叉树进阶
王道数据结构代码实现C语言
07-29
王道数据结构提供了一系列的代码实现，包括顺序表、链表、栈队列、二叉树、图以及查找排序等部分的代码实现。\[1\]这些代码实现使用了C语言来实现各种数据结构的功能。 例如，可以使用createDouLoopLink函数来创建...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值