链表操作

最新推荐文章于 2023-08-28 11:15:45 发布
最新推荐文章于 2023-08-28 11:15:45 发布
阅读量358 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013322907/article/details/37880525
版权

1、单链表的建立、查找、插入、删除、排序、逆置


#include <iostream>
#include <algorithm>
using namespace std;

struct node
{
	int data;
	node *next;
};
//建立
node* Create()
{
	int i=0;
	node *head=0;
	node *p1=0;
	node *p2=0;
	cin>>i;
	while(-1!=i)
	{
		//cout<<"输入链表的值，以-1结束"<<endl;
		
		if(head==0)
		{
			head=new node();
			head->data=i;
			p1=head;
		}
		else
		{
			p2=new node();
			p2->data=i;
			p1->next=p2;
			p1=p2;
		}
		cin>>i;
	}
	//链表结束
	if(head!=0)
		p1->next=0;//链尾指向0
	return head;
}
//遍历
void Print(node* head)
{
	node *p;
	if(!head)
	{
		cout<<"NULL"<<endl;
	}
	else
	{
		p=head;
		while(p)
		{
			cout<<p->data<<' ';
			p=p->next;
		}
	}
	cout<<endl;
}

int Length(node* const head)
{
	int i=0;
	if(head==0)
		return 0;
	node *p=head;
	while(p!=0)
	{
		i++;
		p=p->next;
	}
	return i;
}
//删除
node*  Delete(node * head,int val)
{
	node *p1,*p2;
	if(!head)
	{
		cout<<"空链表"<<endl;
		return NULL;
	}
		p1=head;
		p2=head;
		if(head->data==val)//删除头结点
		{
			head=head->next;
			delete p1;
			return head;
		}
		while(p2->data!=val && p2->next!=NULL)
		{
			p1=p2;
			p2=p2->next;
		}
		if(p2->next==0 && p2->data!=val)
		{
			cout<<"没有找到:"<<endl;
			return head;
		}
		if(p2->next==0 && p2->data==val)
		{
			cout<<"找到,在最后一个结点"<<endl;
			p1->next=0;
			delete p2;
			return head;
		}
		if(p2->next!=0)
		{
			p1->next=p2->next;
			delete p2;
			cout<<"找到了"<<endl;
			return head;
		}
	
}
node* Insert(node* head,int val)
{
	if(!head)//1空链表
	{
		head=new node();
		head->data=val;
		head->next=0;
		return head;
	}
	node *p1=head,*p2=head,*p3=new node();
	p3->data=val;
	if(head->data>=val)//2、在首节点插入
	{
		p3->next=head;
		head=p3;
		return head;
	}
	while( p2!=0 && p2->data<val)//顺序不能反，否则会错
	{
		p1=p2;
		p2=p2->next;
	}
	if(p2==0)
	{
		p1->next=p3;
		p3->next=0;
		return head;
	}
	else
	{
		p1->next=p3;
		p3->next=p2;
		return head;
	}
}
//排序
node* Sort(node *head)
{
	if(!head)
		return NULL;
	
	if(head->next==0)
		return head;

	node *p1=head,*p2=head->next,*p3=0;
	while(p1->next!=0)
	{
		while(p2!=0)
		{
			if(p1->data>p2->data)
			{
				int n;
				n=p1->data;
				p1->data=p2->data;
				p2->data=n;
			}
			else
			{
				p2=p2->next;
			}
		}
		p1=p1->next;
		p2=p1;
	}
	return head;
}
//反转
node* Reverse(node* head)
{
	if(head==0 || head->next==0)
		return head;
	node *p1=head,*p2=head->next,*p3;
	head->next=0;
	while(p2!=0)
	{
		p3=p2;
		p2=p2->next;
		p3->next=p1;
		p1=p3;
	}
	head=p1;
	return head;
}
void main()
{
	node *list1=0;
	list1=Create();
	


	node *list2=0;
	list2=Insert(list1,9);
	list2=Sort(list2);
	list2=Reverse(list2);
	Print(list2);
	

	

	system("pause");
}


2、双指针在单链表中的应用

以下内容转自 http://blog.csdn.net/sicofield/article/details/9005133，感谢原作者sicofield的总结。

      经常能够碰到链表的题，当用一个指针遍历来解决问题的时候，不是无法解决就是效率不佳，典型的就是需要多次遍历且需要额外的存储空间。在这种情况下，可以尝试用两个指针来遍历链表，而两指针遍历链表又可以分为两种情况：1、让其中一个指针遍历快一点，比如一次在链表中走上两步；2、让其中一个指针现在链表中走上若干步。

       这里举三个链表相关的题目。

1、 判定链表中是否环

       第一种方法：可以对链表的元素进行标记，如果在预见NULL节点之前再次碰见已标记节点就存在环。缺点：需要改变节点内容，而节点一般是只读的。

       第二种方法：访问每一个元素将其存储在数组中，这个时候存储的元素是什么，如果链表中的元素有重复的值，难道存储节点地址？并且开辟了O(n)的额外空间，如果内存不够呢？

       第三种方法：如果假定链表存在环，那么环在前N个元素之中，此时可以设置一个指针指向链表的头部，然后遍历后N-1个元素，看是否是指针所指元素，如果都不同，指针指向后一个元素，然后遍历后N-2个元素。缺点：这个算法复杂度为O(n^2)，而且建立在一个前提条件之下。

       最优的答案：设置两个指针，开始都指向链表头，然后其中一个指针每次向前走一步，另一个指针每次向前走两步，如果快的遇到NULL了，证明该链表中没有环，如果有环，快的指针每次都要比慢的多走一步，最终两个指针会相遇，（注意：这里快指针不会跳过慢指针而不相遇，因为它每次都只比慢指针多走一个单位）

[cpp]  view plain copy
  1. bool judge(list *head)  
  2. {  
  3.     if(head == NULL)  
  4.     {  
  5.         return false;//没有环  
  6.     }  
  7.   
  8.     list *pFast = head;  
  9.     list *pSlow = head;  
  10.   
  11.     while(pFast->next != NULL && pFast->next->next != NULL)  
  12.     {  
  13.         pFast = pFast->next->next;  
  14.         pSlow = pSlow->next;  
  15.   
  16.         if(pFast == pSlow)  
  17.         {  
  18.             return true;  
  19.         }  
  20.     }  
  21.   
  22.     return false;  
  23. }  

2、找到链表的中间节点

       受上一题的启发可以运用两个速度不同的指针来解决，快指针每次走两步，慢指针每次走一步，这样当快指针到达链表尾部的时候，慢指针就指向了链表的中间节点。

3、 输出链表中倒数第K个数

第一种方法：单个指针遍历两次，首先遍历一次链表统计总元素个数N，那么所要找的倒数第K个元素即为第N-K+1个元素。

第二种方法：双指针遍历一次，首先前指针先向前走K-1步，即初始的时候前指针指向第K个元素，然后后指针指向第一个元素，然后同步向后单步走，当后指针指向NULL的时候，前指针指向倒数第K个元素。

[cpp]  view plain copy
  1. //注意程序鲁棒性，输入参数检查，元素个数不足检查。  
  2. ListNode* FindKthToTail(ListNode* pListHead, unsigned int k)  
  3. {  
  4.     if(pListHead == NULL || k == 0)  
  5.         return NULL;                        //考虑参数异常  
  6.   
  7.     ListNode *pAhead = pListHead;  
  8.     ListNode *pBehind = NULL;  
  9.   
  10.     for(unsigned int i = 0; i < k - 1; ++ i)  
  11.     {  
  12.         if(pAhead->m_pNext != NULL)  
  13.             pAhead = pAhead->m_pNext;  
  14.         else                               //要考虑到链表的元素不足K个的情况  
  15.         {  
  16.             return NULL;  
  17.         }  
  18.     }  
  19.   
  20.     pBehind = pListHead;  
  21.     while(pAhead->m_pNext != NULL)  
  22.     {  
  23.         pAhead = pAhead->m_pNext;  
  24.         pBehind = pBehind->m_pNext;  
  25.     }  
  26.   
  27.     return pBehind;  
  28. }  

4、 两链表的第一个公共结点——输入两个链表，找出它们的第一个公共结点。

[cpp]  view plain copy
  1. unsigned int GetListLength(ListNode* pHead)  
  2. {  
  3.     unsigned int nLength = 0;  
  4.     ListNode* pNode = pHead;  
  5.     while(pNode != NULL)  
  6.     {  
  7.         ++ nLength;  
  8.         pNode = pNode->m_pNext;  
  9.     }  
  10.       
  11.     return nLength;  
  12. }  
  13. ListNode* FindFirstCommonNode( ListNode *pHead1, ListNode *pHead2)  
  14. {  
  15.     // 得到两个链表的长度  
  16.     unsigned int nLength1 = GetListLength(pHead1);  
  17.     unsigned int nLength2 = GetListLength(pHead2);  
  18.     int nLengthDif = nLength1 - nLength2;  
  19.    
  20.     ListNode* pListHeadLong = pHead1;  
  21.     ListNode* pListHeadShort = pHead2;  
  22.     if(nLength2 > nLength1)  
  23.     {  
  24.         pListHeadLong = pHead2;  
  25.         pListHeadShort = pHead1;  
  26.         nLengthDif = nLength2 - nLength1;  
  27.     }  
  28.    
  29.     // 先在长链表上走几步，再同时在两个链表上遍历  
  30.     for(int i = 0; i < nLengthDif; ++ i)  
  31.         pListHeadLong = pListHeadLong->m_pNext;  
  32.    
  33.     while((pListHeadLong != NULL) &&   
  34.         (pListHeadShort != NULL) &&  
  35.         (pListHeadLong != pListHeadShort))  
  36.     {  
  37.         pListHeadLong = pListHeadLong->m_pNext;  
  38.         pListHeadShort = pListHeadShort->m_pNext;  
  39.     }  
  40.    
  41.     // 得到第一个公共结点  
  42.     ListNode* pFisrtCommonNode = pListHeadLong;  
  43.    
  44.     return pFisrtCommonNode;  
  45. }  

        顺便说一句，单链表翻转的算法运用了3指针，这是为了记录前后节点。
u013322907
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言链表操作详解
qq_41481924的博客
12-29 14万+
为什么要使用链表 在未学习链表时，我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快，但是它的弊端也很明显： 使用前需声明数组的长度，一旦声明长度就不能更改 插入和删除操作需要移动大量的数组元素，效率慢 只能存储一种类型的数据. 而链表则可以实现以上这些数组所不具备的功能，此时引入了结构体来实现创建链表的操作。 链表的特点： n个节点离散分配 每一个节...
【链表】(二) 双指针技巧
闻韶
07-14 848
LeetCode - 探索卡片 - 链表 - 二 - 双指针技巧
关于链表算法题的双指针
sicofield的专栏
06-01 4342
经常能够碰到链表的题，当用一个指针遍历来解决问题的时候，不是无法解决就是效率不佳，典型的就是需要多次遍历且需要额外的存储空间。在这种情况下，可以尝试用两个指针来遍历链表，而两指针遍历链表又可以分为两种情况：1、让其中一个指针遍历快一点，比如一次在链表中走上两步；2、让其中一个指针现在链表中走上若干步。        这里举三个链表相关的题目。 1、 判定链表中是否环        第一种方法
链表——环形链表（双指针）
周小兔的大管家的博客
06-12 179
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。不允许修改 链表。示例 1：输入：head = [3,2,0,-4], pos = 1 输出：返回索引为 1 的链表
链表中双指针的技巧
m0_61130325的博客
04-26 1368
链表中双指针的技巧
双指针-链表
chuxuezhe8483的博客
04-03 372
双指针-链表 83. 删除排序链表中的重复元素 给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。 class Solution { public: ListNode* deleteDuplicates(ListNode* head) { if(head == NULL) return head; auto slow = head,fast = head; while(fast!=NULL){
链表操作演示程序Java版
01-19
在这个“链表操作演示程序Java版”中，我们看到开发者利用Java语言和JavaFX库创建了一个可视化工具，用于展示链表的各种操作。JavaFX是一个用于构建桌面、移动和嵌入式平台的富客户端应用程序的开源框架。 1. **...
lianbiao.rar_链表基本操作_链表操作
09-24
- **链表的合并与排序**：在排序链表或合并两个已排序链表时，链表操作尤为重要，如归并排序、插入排序等。 - **链表的反向**：将链表的顺序反转，这涉及到对节点的重新连接。 链表是数据结构中的基础，理解和...
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
C语言是实现链表操作的常用工具，它提供了丰富的指针操作功能，使得我们能方便地创建、插入、删除和遍历链表节点。"C11.C"文件很可能包含了实现这些操作的代码，例如： 1. **链表的创建**：首先，需要定义链表节点...
c语言编程题之链表操作设计链表.zip
最新发布
03-30
链表是一种重要的数据结构，在...通过解决此类链表操作的编程题目，你可以深入理解链表数据结构，提高C语言编程能力，同时对动态内存管理和指针操作有更清晰的认识。实践中不断练习，才能更好地掌握这些核心概念。
链表双指针问题
qq_43533956的博客
03-04 689
让我们从一个经典问题开始：给定一个链表，判断链表中是否有环。 想象一下，有两个速度不同的跑步者。如果他们在直路上行驶，快跑者将首先到达目的地。但是，如果它们在圆形跑道上跑步，那么快跑者如果继续跑步就会追上慢跑者。 这正是我们在链表中使用两个速度不同的指针时会遇到的情况： 如果没有环，快指针将停在链表的末尾。 如果有环，快指针最终将与慢指针相遇。 一般来说我们把快指针的速度设为2，慢指针设为1。 求环形链表的入环点 问题描述：给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如
链表之双指针（快慢指针，先后指针，首尾指针）
weixin_51818357的博客
07-04 1521
链表之双指针（快慢指针，先后指针）
链表之双指针
Blog of Leviash
02-27 424
快慢指针就是存在两个指针，一个快指针，一个慢指针，两个指针每次移动的速度不一样，快的移动的快，慢的移动的慢。快慢指针中的快慢指的是移动的步长，即每次向前移动速度的快慢。例如可以让快指针每次沿链表向前移动2，慢指针每次向前移动1次。
链表的双指针问题
学习中
08-28 170
链表的双指针问题
链表双指针
qq_44819554的博客
02-22 448
链表双指针常见的题目有合并k个有序链表、判断链表中是否有环、如果有环返回第一个入环结点、是否相交链表、链表的中间结点、K个一组翻转链表、删除排序链表中重复的元素、反转链表、回文链表等，其中最长考的就是反转链表（全部反转，部分翻转），又分为递归实现和迭代实现。
Java单链表链表中的双指针
起个破名真费劲..的博客
07-30 679
本篇文章记录了常用的双指针链表操作：1.链表环检测；2.查找链表环入口；3.删除链表倒数第n个结点；4.回文链表；
单链表的双指针法
qq_53558968的博客
03-21 678
快慢指针 一位数学教授说过这样一句话， 好的结构一定会有好的结果。 链表作为一种优美的结构，它弥补了顺序表的一些缺点。这篇博客就我这几天在leetcode做题总结一下技巧。 Q1： 给定一个头结点为 head 的非空单链表，返回链表的中间结点。 如果有两个中间结点，则返回第二个中间结点。 题目链接：leetcode–链表的中间结点 来源：力扣（LeetCode） 输入：1-> 2-> 3-> 4 返回 3的结点 输入 1 ->2-> 3-> 4-> 5 返
单链表的排序-双指针
Lucky_main的博客
06-28 153
单链表的排序，归并排序，双指针
160.相交链表（双指针法）
夜阑優琿
11-15 136
解题思路 1.双指针法：让指针1遍历完链表1后指向链表2的第一个节点，指针2遍历完链表2后指向链表1的第一个节点。这样指针1遍历完链表2后，和指针2遍历完链表1后走过的总距离就是一样的，因此当两个指针都进入第二个链表后就可以保证它们离表尾的距离相同，就可以轻松判断是否相交了。 2.链表的最后一个节点的next域通常是指向NULL的，指针在操作链表的时候也可以指向这个NULL（即指向最后一个节点还能->next），所以通常把这个NULL也理解为链表的一个节点来操作。比如在这里指针是指向NULL后再指向第
C++实现链表操作详解
创建链表是链表操作的基础，这涉及到在内存中动态分配空间并初始化结点。在C++中，可以使用new运算符来动态分配内存。检索操作则是根据特定的索引或条件寻找链表中的结点。由于链表不是顺序存储，所以检索可能需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值