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

已于 2023-10-03 15:28:08 修改
阅读量49 收藏
点赞数
文章标签： c语言 c++ 数据结构
于 2023-10-02 09:22:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52670590/article/details/133483715
版权

第一次写的有bug,下面已经将代码改正

  1. 在删除节点后，应该将 p 的 next 指针指向被删除节点 q 的下一个节点。这是因为在链表中删除一个节点后，应该使前一个节点指向被删除节点的下一个节点，而不是将前一个节点的数据域设置为被删除节点的数据域。

  2. 在删除节点后，应该将 q 的 next 指针置为 NULL，以避免悬挂指针。

  3. bool ListDelete(LinkList& L, int i, int& e)
{
    if (i < 1)
    {
        return false;
    }
    LNode* p = GetElem(L, i - 1); // 获取前一个元素
    if (!p || !(p->next))
    {
        return false;
    }
    LNode* q = p->next; // 待删除节点
    e = q->data;
    p->next = q->next; // 修改前一个节点的指针
    free(q); // 释放被删除节点的内存
    return true;
}

 改正前

#include<iostream>
#include<algorithm>

using namespace std;

typedef struct LNode {

	int data;
	struct LNode* next;
}LNode,*LinkList;
//初始化操作
bool InitList(LinkList& L)
{
	L = (LNode*)malloc(sizeof(LNode));//分配一个空的头节点。
	if (!L)
	{
		return false;
	}
	L->next = NULL;
	return true;

}
//头插法
LinkList List_HeadInsert(LinkList& L)
{
	int x;
	L = (LNode*)malloc(sizeof(LNode));
	L->next = NULL;
	cout << "请输入数值:";
	cin >> x;
	LNode* s;
	while (x != 999)
	{
		s= (LNode*)malloc(sizeof(LNode));
		s->data = x;
		s->next = L->next;
		L->next = s;
		cin >> x;
	}

	return L;
}
//尾插法
LinkList List_TailInsert(LinkList& L)
{
	int x;
	L = (LNode*)malloc(sizeof(LNode));
	L->next = NULL;
	LNode* s, * r;
	r = L;
	cin >> x;
	while (x != 999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;

        
		cin >> x;
	}
	r->next = NULL;
	return L;


}
//按值查找,找到数据域为e的节点
LNode* LocateElem(LinkList L, int e)
{
	LNode* p = L -> next;
	while (p && p->data != e)
	{
		p = p->next;
	}
	return p;
}
//统计单链表的长度
int Length(LinkList L)
{
	int len = 0;
	LNode* p = L;
	while(p->next)
	{
		len++;
		p = p->next;
	}

	return len;
}
//按位查找，返回第i个元素（带头节点）
LNode* GetElem(LinkList L, int i)
{
	if (i < 0)
	{
		return NULL;

	}
	int j = 0;
	LNode* p = L;
	while (p && j < i)
	{
		p = p->next;
		j++;
	}
	return p;
}
//后插操作，在节点p之后插入元素e
bool InsertNextNode(LNode* p,int e)
{
	if (!p)
	{
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (!s)
	{
		return false;
	}
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}
//带头节点的插入操作，在第i个位置插入元素e
bool ListInsert(LinkList& L, int i, int e)
{
	if (i < 1)
	{
		return false;

	}
	LNode* p = GetElem(L, i - 1);//找到前一个元素
	if (!p)
	{
		return false;
	}
	return InsertNextNode(p, e);





}
//前插操作，在节点p之前插入节点s
bool InsertPriorNode(LNode* p, LNode* s)
{
	if (!p||!s)
	{
		return false;
	}
	s->next = p->next;
	p->next = s;
	swap(s->data, p->data);


}
//前插操作，在P节点前插入元素e
bool InsertPriorNodee(LNode* p, int e)
{
	if (!p)
	{
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (!s)
	{
		return false;
	}
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;


	return true;

}
//删除位序为i的节点,e是i节点的值
bool ListDelete(LinkList& L, int i, int& e)
{
	if (i < 1)
	{
		return false;
	}
	LNode* p= GetElem(L, i - 1);//获取删除前一个元素的值；
	if (!p || !(p->next))
	{
		return false;
	}
	LNode* q = p->next;
	e = q->data;
	p->data = q->data;
	free(q);
	return true;



}
//删除指定节点p
bool deleteNode(LNode* p)//把后驱的值赋给p,再让p跳过后驱，释放后驱。
{
	if (p->next == NULL)
	{
		return false;
	}
	LNode* q = p->next;
	p->data = q->data;
	p->next = q->next;
	free(q);
	return true;

}
//打印头结点单链表 
void print(LinkList L)
{
	LNode* s = L;
	while (s->next != NULL)
	{
		s = s->next;//一直向后指
		cout << s->data << " ";
	}
	cout << endl;


}
int main()
{
	LinkList L;
	InitList(L);//初始化
	List_HeadInsert(L);//头插法
	cout<<"打印当前链表";
	print(L);//打印链表
	cout << endl;
	cout << "链表的长度" << Length(L) << endl;
    cout << "链表的第二个元素" << GetElem(L, 2)->data << endl;
	int e;
	ListDelete(L, 3, e);
	cout << "删除的第三个元素是" << e;
	cout << endl;
	cout<<"打印当前链表"<<endl;
	print(L);
	ListInsert(L,3,e);
	cout<<"当前插入的第3个元素是"<<e<<endl;
	cout<<"打印当前链表"<<endl;
	print(L);
	LNode* s = LocateElem(L, 5);//按值查找数据域等于e的节点，
		return 0;
}

改正后

#include<iostream>
#include<algorithm>

using namespace std;

typedef struct LNode {

	int data;
	struct LNode* next;
}LNode,*LinkList;
//初始化操作
bool InitList(LinkList& L)
{
	L = (LNode*)malloc(sizeof(LNode));//分配一个空的头节点。
	if (!L)
	{
		return false;
	}
	L->next = NULL;
	return true;

}
//头插法
LinkList List_HeadInsert(LinkList& L)
{
	L = (LNode*)malloc(sizeof(LNode));
	L->next = NULL;
	cout << "请输入数值:";
	LNode* s;
	int x;
	while (cin>>x)
	{
		s= (LNode*)malloc(sizeof(LNode));
		s->data = x;
		s->next = L->next;
		L->next = s;
	}

	return L;
}
//尾插法
LinkList List_TailInsert(LinkList& L)
{
	int x;
	L = (LNode*)malloc(sizeof(LNode));
	L->next = NULL;
	LNode* s, * r;
	r = L;
	cin >> x;
	while (x != 999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;

        
		cin >> x;
	}
	r->next = NULL;
	return L;


}
//按值查找,找到数据域为e的节点
LNode* LocateElem(LinkList L, int e)
{
	LNode* p = L -> next;
	while (p && p->data != e)
	{
		p = p->next;
	}
	return p;
}
//统计单链表的长度
int Length(LinkList L)
{
	int len = 0;
	LNode* p = L;
	while(p->next)
	{
		len++;
		p = p->next;
	}

	return len;
}
//按位查找，返回第i个元素（带头节点）
LNode* GetElem(LinkList L, int i)
{
	if (i < 0)
	{
		return NULL;

	}
	int j = 0;
	LNode* p = L;
	while (p && j < i)
	{
		p = p->next;
		j++;
	}
	return p;
}
//后插操作，在节点p之后插入元素e
bool InsertNextNode(LNode* p,int e)
{
	if (!p)
	{
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (!s)
	{
		return false;
	}
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}
//带头节点的插入操作，在第i个位置插入元素e
bool ListInsert(LinkList& L, int i, int e)
{
	if (i < 1)
	{
		return false;

	}
	LNode* p = GetElem(L, i - 1);//找到前一个元素
	if (!p)
	{
		return false;
	}
	return InsertNextNode(p, e);





}
//前插操作，在节点p之前插入节点s
bool InsertPriorNode(LNode* p, LNode* s)
{
	if (!p||!s)
	{
		return false;
	}
	s->next = p->next;
	p->next = s;
	swap(s->data, p->data);


}
//前插操作，在P节点前插入元素e
bool InsertPriorNodee(LNode* p, int e)
{
	if (!p)
	{
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (!s)
	{
		return false;
	}
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;


	return true;

}
//删除位序为i的节点,e是i节点的值
bool ListDelete(LinkList& L, int i, int& e)
{
	if (i < 1)
	{
		return false;
	}
	LNode* p = GetElem(L, i - 1); // 获取前一个元素
	if (!p || !(p->next))
	{
		return false;
	}
	LNode* q = p->next; // 待删除节点
	e = q->data;
	p->next = q->next; // 修改前一个节点的指针
	free(q); // 释放被删除节点的内存
	return true;
}

//删除指定节点p
bool deleteNode(LNode* p)//把后驱的值赋给p,再让p跳过后驱，释放后驱。
{
	if (p->next == NULL)
	{
		return false;
	}
	LNode* q = p->next;
	p->data = q->data;
	p->next = q->next;
	free(q);
	return true;

}
//打印头结点单链表 
void print(LinkList L)
{
	LNode* s = L;
	while (s->next != NULL)
	{
		s = s->next;//一直向后指
		cout << s->data << " ";
	}
	cout << endl;


}
int main()
{
	LinkList L;
	//InitList(L);//初始化
	List_HeadInsert(L);//头插法
	print(L);//打印链表
	cout << endl;
	cout << "链表的长度" << Length(L) << endl;
	cout << "链表的第二个元素" << GetElem(L, 2)->data << endl;
	int e;
	ListDelete(L, 3, e);
	cout << "删除的第三个元素是" << e;
	cout << endl;
	cout << "打印当前链表";
	print(L);
	cout << endl;
	LNode* s = LocateElem(L, 5);//按值查找数据域等于e的节点，
		return 0;
}

一心向北（孙官方）
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构：单链表带头结点
weixin_58368590的博客
01-15 260
#include <stdio.h> #include <assert.h> #include <stdlib.h> #include "list.h" /* 需要前驱的操作函数：插入，删除等(让指针p指向头结点，判断依据是下一个节点存不存在，存在的话向后走一步) for(struct Node *p=plist; p->next!=NULL; p=p->next);//如果指针p循环外还使用，就提到for外面定义 不需要前驱的操作函数：查找，获取有效.
链表-使用C语言实现带头结点的单链表.zip
03-13
链表 链表_使用C语言实现带头结点的单链表
C++ 单链表（带头结点）
qq_43650934的博客
11-17 5284
#include <iostream> #include <stdio.h> #include <string> using namespace std; // 单链表结点 struct LNode { int data; // 数据域 LNode *next; // 指针域 }; // 单链表 struct LinkList { LNode *head; // 头结点 int length; // 单链表长度 }; //
单链表带头结点与不带头结点插入的区别
Prosperity_c的博客
02-05 1682
单链表带头结点与不带头结点插入的区别 · 带头结点与不带头结点区别： 1.带头结点不用改变头指针 因为头指针永远指向头结点 2.而不带头结点 在第1个位置插入结点时 需要改变头指针 bool ListInsert1(LinkList &L, int I, int e);//按位序插入操作。在表L中的第i个位置插入指定元素e（带头结点） **采用后插操作 bool ListInsert2(LinkList &L, int I, int e);//按位序插入操作。在表L中的第i个位置插入指定元
数据结构学习笔记——线性表的链式表示（单链表带头结点和不带头结点的基本操作）
小宇y的博客
04-10 8152
目录单链表的相关知识点（一）单链表的定义（二）单链表的初始化和空表判断（三）单链表的建立（四）单链表的输出（五）单链表的逆序输出（六）单链表的插入操作（七）单链表的删除操作（）（） 单链表的相关知识点 单链表是链式存储的，其每个结点除了存放数据元素之外，还存储指向下一个结点的指针；而顺序表是顺序存储的，其每个结点只存放数据元素。【顺序存储结构可以随机存取、顺序存取，而链式存储结构只能顺序存取】 顺序存储结构不仅可用于存储线性结构，还能用于树、图。 若需对表进行频繁的插入、删除操作，此时适合选链式存储。 一
C++单链表带头结点和不带头结点初始化操作
weixin_44789391的博客
05-14 397
#include <iostream> using namespace std; // 单链表不带头结点 typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNoded, *LinkList; // 初始化一个空的单链表 bool InitList(LinkList &L) { L = NULL; // 赋值 return true; } // 判断是不是空的
单链表———带头结点跟不带头结点的区别
weixin_46402351的博客
04-10 1万+
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、单链表：带头结点跟不带头结点二、使用步骤总结 前言 数据结构中单链表的创建 带头结点跟不带头结点的区别 一、单链表：带头结点跟不带头结点 指针：通常使用“头指针”来标识一个链表，如单链表L，头指针为NULL的时表示一个空链表。链表非空时，头指针指向的是第一个结点的存储位置。 头结点：在单链表的第一个结点之前附加一个结点，称为头结点。头结点的Data域可以不设任何信息，也可以记录表长等相关信息。若链表是带有头结点的，则头指.
单链表指针和头结点的理解
新海说
11-19 7378
线性表使用顺序（数组）存储时有个弊端，那就是在插入和删除时需要大量的移动数据，这显示是非常消耗时间的，所以可以采用链式存储，即有一个指针域（单链表），来记录下个结点的存储位置（地址），这样在插入和删除结点时只需要修改指针域即可，从而大量减少移动数据所消耗的时间。来看链表的定义： struct node { int data; struct node *next; }; 其中有两个元素，dat...
单链表有头节点与无头结点的区别
热门推荐
weixin_46273997的博客
02-15 1万+
1.先区分一下概念： 头结点： 在单链表第一个元素结点之前设置的一个结点，数据域可以不存任何信息，指针域指向单链表第一个元素的结点。对于单链表来说，头结点可有可无，但为了操作方便，一般情况下单链表都具有头结点，后面的分析将会区别一下有头结点和没有头结点的区别。 优点：减少了单链表添加删除时特殊情况的判断，减少了程序的复杂性，主要是添加和删除在第一个有元素的结点（首元结点）上有区别，如果链表没有头...
【考研】分清带头结点和不带头结点的单链表
qq_34438969的博客
10-09 4553
为分清带结点与不带头结点的单链表操作，本文以图文和表格形式描述了两者之间的区别。考研中，数据结构的单链表操作是重要考点，其中，比较常考带头结点的链表操作。本文包含了带头结点的插入、删除、查找、用前插法和后插法创建单链表等基本操作。【考研】数据结构考点——直接插入排序_住在阳光的心里的博客-CSDN博客【考研】单链表相关算法（从基础到真题）_住在阳光的心里的博客-CSDN博客。
单链表.rar_数据结构_C/C++_
08-10
使用c语言，用单链表完成学生管理系统，使用单链表完成对学生信息的读取、学生增删、指针交换实现姓名/学号/单科成绩的排序，由学生姓名或学号进行查询学生全部信息，实现学生数量无限制的链式结构，可对学生进行...
数据结构与算法 c++实现 //删除顺序递增表中的重复元素 //对单链表实现就地逆置 //删除递增单链表中的重复元素
06-04
数据结构与算法 c++实现 //删除顺序递增表中的重复元素 //对单链表实现就地逆置 //删除递增单链表中的重复元素 适合大二初学数据结构与算法 程序有详细备注 顺序表 单链表
单链表（带头结点）.cpp
08-01
实现单链表及其一些基本操作函数（带头结点） 1.头文件包含 2.宏定义及节点类型描述 3.初始化、判断是否为空 4.指定位置插入操作 5.在p节点后插入元素e 6.在p节点前插入元素e 7.删除操作：删除第i个节点，元素...
单链表_c语言/单链表_
09-29
典型的c语言数据结构单链表
深入理解交叉熵损失 CrossEntropyLoss - CrossEntropyLoss
flyfish
06-09 1189
在二分类问题中，我们可以使用 nn.BCEWithLogitsLoss，它会在内部应用 Sigmoid 激活函数，并计算二分类的交叉熵损失。 在多分类问题中，我们可以使用 nn.CrossEntropyLoss，它会在内部应用 Softmax 激活函数，并计算多分类的交叉熵损失
【C++】——Stack与Queue（含优先队列（详细解读）
最新发布
m0_74092462的博客
06-09 977
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 132
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 649
LeetCode 算法：轮转数组c++
C语言单链表带头结点
07-28
在C语言中，单链表带头结点是指在链表的头部添加一个额外的结点，该结点不存储任何数据，仅用于标记链表的起始位置。引用\[3\]中的代码展示了一个带头结点的单链表的定义，其中node*表示指向一个结点的指针，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值