数据结构之单向链表操作1-(插入,删除，交换，反转，排序等操作)

最新推荐文章于 2022-11-16 21:38:21 发布
最新推荐文章于 2022-11-16 21:38:21 发布
阅读量1.7k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法 文章标签： 数据结构 链表 操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wwq2015/article/details/48290357
本文详细介绍了单向链表的基本概念、实现方式及常见操作，包括创建、插入、删除、查找、获取元素、反转链表等，并通过实例代码展示链表的使用方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

第一次写博客，也是为了激励自己学习，可能还不太懂(～￣▽￣)～，而且代码上可能还有些不太足，敬请赐教！！！


如标题所示，这次演示单向链表的一些基本的操作，有些地方可能没有考虑周到，ORZ~

首先是些基本的声明如下

template<typename T>		
struct Node{		//结点
	T data;
	Node * next;
};		

template<typename T>
class LinkList{
private:
	Node<T> * head;		//头指针	
public:
	LinkList();				//创建容量为m的空表
	~LinkList();
	void CreateList(int n);		//创建表长为n的线性表
	void Insert(int i, T e);	//在i位置插入值e
	T Delete(int i);			//删除i位置的值并返回它
	int Locate(T e);			//通过给定值查找线性表中第一个等于此值的数，返回其序列号
	T GetElem(int i);			//获取i位置的值
	T Prior(T e);				//返回元素e的前驱
	int Length();				//返回表长
	bool Empty();				//检查表是否为空
	void Clear();				//清空表
	void LinkListTraverse();	//遍历表中的元素
	void Reverse();				//反转链表
	Node<T> * FindNode(int i);	//通过给定序号返回结点
	Node<T> * FindPro(int i);		//通过给定序号返回前驱结点
	void Exchange(int i, int j);	//交换链表中的两个结点
	void InsertSort();			//插入排序链表
};


函数的定义


template<typename T>
LinkList<T>::LinkList()
{
	head = new Node<T>;
	if (!head)
		throw "内存分配失败 \n";
	head->next = NULL;              //建立带头结点的链表
}

//删除结点，释放内存
template<typename T>
LinkList<T>::~LinkList()
{
	Node<T> *p;		//临时结点指针,保存要释放的结点
	while (head)
	{
		p = head;
		head = head->next;        //通过让p保存当前要释放的结点,然后让head往下移动，再释放p指向的空间,循环如此达到完全释放
		delete p;
	}
}

//尾插法
template<typename T>
void LinkList<T>::CreateList(int n)
{
	Node<T> *p = head, *s;		//p保存当前结点，s指向新结点
	cout << "输入数据: ";
	for (int i = 0; i < n; ++i)
	{
		s = new Node<T>;
		cin >> s->data;
		s->next = p->next;      //让p从头结点开始，再把新结点接到p结点后面
		p->next = s;
		p = s;                  //接完后，再让p结点指向新结点，循环
	}
}

////头插法，比尾插法少了p保存新结点，这样让每次新结点都在头插入
//template<typename T>
//void LinkList<T>::CreateList(int n)
//{
//	cout << "输入数据: ";
//	for (int i = 0; i < n; ++i)
//	{
//		s = new Node<T>;
//		cin >> s->data;
//		s->next = head->next;
//		head->next = s;
//	}
//}

//返回表长(不包含头结点)
template<typename T>
int LinkList<T>::Length()
{
	int i = 0;
	Node<T> * p = head->next;	//p指向首结点开始计数
	while (p)
	{
		++i;
		p = p->next;
	}

	return i;
}

//在i位置插入值e
template<typename T>
void LinkList<T>::Insert(int i, T e)
{
	Node<T> * p = head, * s;
	int cnt = 1;		//计数
	while (p && cnt < i)
	{
		p = p->next;		//定位到i-1的位置
		cnt++;
	}
	if (!p || cnt > i)
		throw "插入位置出错 \n";		//i大于表长或者小于0
	s = new Node<T>;
	if (!s)
		throw "内存分配失败 \n";
	s->data = e;
	s->next = p->next;
	p->next = s;
}

//删除i位置的值并返回它
template<typename T>
T LinkList<T>::Delete(int i)
{
	if (Length() == 0)
		throw "无元素存在，不需要删除 \n";
	Node<T> *p = head;
	int j = 1;
	while (p && j < i)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i)
		throw "插入位置出错 \n";
	T e = p->next->data;
	Node<T> *s = p->next;     //保存要释放的结点
	p->next = p->next->next;
	delete s;

	return e;
}
//通过给定值查找线性表中第一个等于此数，返回其序列号
template<typename T>
int LinkList<T>::Locate(T e)
{
	Node<T> *p = head->next;
	int cnt = 0;
	while (p)
	{
		cnt++;
		if (p->data == e)
			return cnt;			//返回序列号
		p = p->next;
	}
	cout << "没有找到元素 \n";
	return 0;				//返回0表示没有找到
}

//获取i位置的值
template<typename T>
T LinkList<T>::GetElem(int i)
{
	Node<T> *p = head->next;
	int j = 1;
	while (p && j < i)
	{
		p = p->next;
		j++;			//定位到i位置，注意和前面定位到i-1的区别
	}
	if (!p || j > i)
		throw "插入位置出错 \n";
	return p->data;
}

template<typename T>
//返回元素e的前驱
T LinkList<T>::Prior(T e)
{
	Node<T> *p = head->next;
	int cnt = 0;
	while (p)
	{
		cnt++;
		if (p->next->data == e)
			return p->data;
		p = p->next;
	}
	cout << "没有找到元素 \n";
	return 0;				//返回0表示没有找到
}

//检查表是否为空
template<typename T>
bool LinkList<T>::Empty()
{
	int len = Length();
	return len == 0;         
}

//清空表(和析构函数完全摧毁链表相比,保留头结点)
template<typename T>
void LinkList<T>::Clear()
{
	Node<T> * p = head->next;
	while (p)
	{
		Node<T> * s = p;
		p = p->next;
		delete s;
	}
	head->next = NULL;      //最后记得要将头结点的next置空
}

template<typename T>
//遍历表中的元素
void LinkList<T>::LinkListTraverse()
{
	Node<T> *p = head->next;
	while (p)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}

//反转链表
template<typename T>
void LinkList<T>::Reverse()
{
	if (head == NULL)
		return;
	Node<T> *curr, *p;		  //curr一直指向首结点
	curr = head->next;
	while (curr->next != NULL)
	{
		p = curr->next;
		curr->next = p->next;
		p->next = head->next;     
		head->next = p;
	}
}

//通过给定序号返回结点
template<typename T>
Node<T> * LinkList<T>::FindNode(int i)
{
	Node<T> *p = head;
	int j = 0;
	while (p && j < i)
	{
		j++;
		p = p->next;		//当j = i时，j实际计数实在i后面一位
	}						//此时p指向i位置的
	if (!p || j > i)
		throw"位置异常 \n";
	return p;
}

//通过给定序号返回前驱结点
template<typename T>
Node<T> * LinkList<T>::FindPro(int i)
{

	Node<T> *p = head;
	int j = 1;
	while (p && j < i)
	{
		j++;
		p = p->next;
	}
	if (!p || j > i)
		throw"位置异常 \n";
	return p;		//返回前驱结点
}

//交换链表中的两个结点
template<typename T>
void LinkList<T>::Exchange(int i, int j)
{
	/*1. 假如两个结点相等, 不交换
	 *2. 两个结点相邻特殊处理
	 *3. 一般情况直接处理
	 */

	//分别找到待交换结点的前驱与后继
	Node<T> * node1 = FindNode(i), * node2 = FindNode(j);	
	Node<T> * prenode1 = FindPro(i), * prenode2 = FindPro(j);
	Node<T> * postnode1 = node1->next, * postnode2 = node2->next;
	if (node1 == node2)
	{
		cout << "两个结点相等 \n";
		return;
	}
	
	//特殊情况处理
	if (prenode2 == node1)		//结点1在结点2的前面
	{
		prenode1->next = node2;
		node2->next = node1;
		node1->next = postnode2;
		return;
	}
	if (prenode1 == node2)
	{
		prenode2->next = node1;
		node1->next = node2;
		node2->next = postnode1;
		return;
	}

	//一般情况直接交换两个结点
	prenode1->next = node2;
	node2->next = postnode1;
	prenode2->next = node1;
	node1->next = postnode2;

}

//插入排序链表
template<typename T>
void LinkList<T>::InsertSort()
{
	Node<T> *first;			//作为无序链表的第一个结点
	Node<T> *t;				//作为无序链表的待插结点
	Node<T> *p, *q;			//作为临时变量
	if (head->next == NULL)
		return;				//保证有结点
	first = head->next->next;	//first指向链表的第二个结点(不包含头结点)
	head->next->next = NULL;

	while (first != NULL)
	{
		for (t = first, q = head->next, p = head; q && q->data < t->data; p = q, q = q->next);		//找到第一个比t->data大的结点
		first = first->next;	//往下移动
		p->next = t;
		t->next = q;
	}
}

主函数

int main(){
	int i, j;
	LinkList<int> LList;

	cout << "请输入你需要的链表表实际长度:";
	cin >> i;
	LList.CreateList(i);
	cout << "表中元素为:";
	LList.LinkListTraverse();
	cout << "插入元素后: \n";
	LList.Insert(2, 33);
	LList.Insert(4, 66);
	cout << "表中元素为:";
	LList.LinkListTraverse();
	cout << "表的长度为:" << LList.Length() << endl;
	cout << "现在进行删除操作: \n";
	cout << "请输入你需要删除的位置:";
	cin >> i;
	cout << "删除的元素为:" << LList.Delete(i) << endl;
	if (LList.Empty())
		cout << "表为空 \n";
	else
		cout << "表不为空 \n";
	cout << "表中元素为:";
	LList.LinkListTraverse();
	cout << "反转链表:";
	LList.Reverse();
	cout << "表中元素为:";
	LList.LinkListTraverse();
	cout << "输入要交换两个结点的序列号:";
	cin >> i >> j;
	LList.Exchange(i, j);		//交换两个结点
	cout << "表中元素为:";
	LList.LinkListTraverse();
	cout << "获取位置4的元素为:" << LList.GetElem(4) << endl;
	cout << "请输入一个链表中存在的数:";
	cin >> i;
	cout << "其序列号为:" << LList.Locate(i) << endl;
	cout << "其前驱元素为:" << LList.Prior(i) << endl;
	cout << "现在进行链表的排序(根据关键字数据大小排序) \n";
	LList.InsertSort();
	cout << "表中元素为:";
	LList.LinkListTraverse();

	LList.Clear();
	cout << "将表中元素清空后: \n";
	if (LList.Empty())
		cout << "表为空 \n";
	else
		cout << "表不为空 \n";

	return 0;
}
难点我觉得应该在于链表反转，排序，有时间再补上解释！(。・_・)/~~~

C语言 单向链表的创建、遍历、排序、删除操作
麻雀飞吧的博客
04-21 2534
参考网上的两个链表案例，整理了一份针对单链表进行创建、遍历、排序、删除操作的代码如下，以备后用。 /** * 链表创建、遍历、排序、删除操作 * */ #include #include #include //定义链表中的节点 typedef struct node { int data; //节点中的成员 struct
c语言实现单链表的操作：创建，删除，插入，反转, 排序等
wahack的专栏
10-29 1659
最近学了数据结构的单链表基本操作：创建，删除，插入，反转，排序等.         如有不当或错误之处，欢迎指正，不胜感激！   #include #include #include int comp(const void *a,const void *b)//用于快排的比较函数 { return (*(int*)a-*(int *)b); } struct node {
单项链表的定位，插入，删除
坚持,才是力量.老实做人,踏实做事.
01-28 789
struct node{ int data; node* next;};struct linklist{ node* head;  //表头指针 int n;       //线性表的长度};int main(int argc, char* argv[]){ printf("Hello World!/n"); return 0;}//定位node* loc(linklist L,int
java单链表交换相邻元素_单链表的基本操作---插入，删除，交，并，相邻元素的交换等...
weixin_30698949的博客
02-13 666
//引用头文件#include "list.h"#include#include"fatal.h"//结构体定义structNode{ElementType Element;Position Next;};//初始化链表List MakeEmpty(List L){if (L !=NULL)DeleteList(L);//如果链表非空，则删除链表L = malloc(sizeof(structNo...
C++单向链表之创建、插入、删除、查找、交换链表节点
starlight_love的博客
05-10 893
链表：&emsp &nbsp 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，链表比较方便插入和删除操作。&emsp &nbsp下面直接通过代码进行展示：包括初始化一个可以指向任何数据类型的链表、链表中指定位置插入节点元素、链表中删除指定位置的节点元素、获取链表的长度
数据结构--单向链表及其增、删、改、查、排序等操作的实现（C语言）
羟基与苯的博客
04-10 2725
文章目录🎃链表🎃单向链表的实现（C语言）📌结点类型描述📌1.创建初始化一个链表结点📌2.从链表尾部插入数据📌3.链表遍历打印📌4.查找链表：按结点序号查找📌5.查找链表：按数据内容查找📌6.在任意位置插入一个数据📌7.删除链表：按结点序号删除📌8.删除链表：按数据内容删除📌9.free释放内存📌10.求链表数据个数🎃单向链表总结 本章内容：单链表的概念；单链表结点模型；单链表的各运算实现。 本文涉及实现单链表完整代码已提交至码云Gitee中，供读者参考。 🎃链表 我们之前实现了数据结构中第一个结构–顺序
数据结构链表的操作
TY113322的博客
03-16 1522
一.链表 1.单链表逆置 解题思路： 使用递归函数，一直递归到链表的最后一个结点，该结点就是反转后的头结点，记作 ret 此后，每次函数在返回的过程中，让当前结点的下一个结点的 next 指针指向当前节点。 同时让当前结点的 next 指针指向 NULL ，从而实现从链表尾部开始的局部反转 当递归函数全部出栈后，链表反转完成。 递归实现版: 非递归实现版本解题思路： 定义两个指针： pre 和 cur ；pre 在前 cur 在后。 每次让 pre 的 next 指向 cur ，实现一次局部反转 局部反转
C 单向链表排序
weixin_54194530的博客
09-06 2885
链表排序链表排序的两种方式一、交换结点的数据域二、断开链表，重新形成方法示例 链表排序的两种方式 一、交换结点的数据域 有很多种方法，比如冒泡排序，选择排序等其他排序方法 struct Node *link_sort(struct Node *head) { int value; struct Node *p = head; struct Node *q = NULL; while(p) { q = p->next; while(q) { if(p->data &g
实用单向链表的基本操作函数24个C语言版
最新发布
03-23
单向链表是一种常见的数据结构，它在计算机科学和编程中有着广泛的应用。在这个C语言实现的案例中，我们有24个不同的函数，用于执行单向链表的各种基础操作。下面将详细介绍这些操作以及它们在实际编程中的作用。 1...
直击高频编程考点：链表知识及经典算法题总结
热门推荐
张彦峰的博客
10-24 5万+
了解链表结构，并在单链表或双链表中实现遍历、插入和删除以及分析在单链表或双链表中的各种操作的复杂度，同时附上相关面试考点的基本分类试题库（反转链表、链表中环的检测、链表中环的入口点、删除链表中倒数第K个节点、两个链表的第一个公共节点、链表的中间节点、合并两个有序链表、删除链表中的重复元素、排序链表、K 个一组翻转链表、旋转链表、分隔链表、奇偶链表、合并k个排序链表、链表相加、回文链表判定、回文链表重排、交换相邻节点、删除指定元素、反转链表指定部分、存在回文链表、链表最长递增子序列）
单链表.c(单链表，使用C语言编写，具有插入、删除、显示等功能)
04-01
单链表，使用C语言编写，具有插入、删除、显示等功能
链表建立，插入，删除，打印操作（C语言实验，指针，结构体）
05-03
包含链表的建立，插入，删除，查找操作，结构清晰，指针及结构体运用灵活，针对性强，有助于对C语言的深入理解
单向链表 结点的插入、筛选、排序等
10-04
我是辽宁工业大学07级学生，为了参加本校的C语言大赛，复习时编了这个程序，拿来跟大家分享一下，希望我们能共同进步！这个程序涉及单向链表的“创建”、“结点删除”、“查找”、“筛选”、“结点插入”、“结点排序”几项内容，并且已在必要的地方写了注释，方便大家阅读程序。本人编此程序花了不少心思，向大家要的分多了点，但绝对物有所值，下了你就知道！
单链表的创建，查找，排序，插入，删除
09-07
1、创建一个带头结点的单链表（头指针为head），且遍历此链表（输出链表中各结点的值）； 2、查找单链表中的第i个结点，并输出结点元素的值； 3、在单链表中的第i个结点前插入一个结点值为e的正整数(从外部输入); 4、删除单链表中的第j个结点； 5、将单链表中的各结点就地逆序（不允许另建一个链表）； 6 查找线性表中的最大元素并输出 7 将线性表中的元素按升序排列；
建立单链表并交换表中任意两个元素
行走江湖的少侠哥
03-12 814
/* *功能：建立单链表并交换表中任意两个元素 *@time：2017年3月12日15:07:25 */ #include #include #include typedef struct node { int pos; int data; node* next; }*LinkList,*linkNode; LinkList CreateList_H(); //创建链表 void
使用单向链表进行交换排序
zhouyinuo1998的博客
11-10 828
思路 1、使用单向链表； 2、排序时只交换节点中的元素，不改变节点的位置。 3、排序采用冒泡排序的方法。 重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。 注意： <1> 每经过一轮的排序，一个最大的元素被“浮”到对应的位置。随之，下一次比较的终点也需要向前移一个元素。 <2> 当正数第二个元素被确定的时候，冒
C语言文件读取和单链表的添加、删除和排序等操作实例
ios开发 知识点 靳会有
11-25 1799
/* 1、从文本文件中导入班级学生信息：学号、姓名、性别、籍贯 2、将学号重复的删除 3、显示导入的学生信息 4、按学号、姓名、性别、籍贯相等和不相等查找 5、多次查找 6、查找结果写入文件 7、VC++6.0编译通过 //以下代码存为main.cpp */ #include #include #include #include #include #inc
数据结构:单向链表系列6--交换相邻两个节点1（交换数据域）
weixin_30399155的博客
08-31 1370
给定一个单向链表,编写函数交换相邻 两个元素 输入: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 输出: 2 -> 1 -> 4 -> 3 -> 6 -> 5 -> 7 输入: 1 -> 2 -> 3 -> 4 -> 5 -> 6 输出: 2...
C++ 单链表节点交换
White--Night的博客
11-16 2551
这里提供两种方法，一种是只交换对应的数据，另一种是通过更改指针来交换节点。而更改指针中又可以分为新建节点与不新建节点的方法。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值