链表的经典问题

最新推荐文章于 2023-11-18 20:36:11 发布
最新推荐文章于 2023-11-18 20:36:11 发布
阅读量198 收藏
点赞数
文章标签： 链表 单链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43229360/article/details/103271744
版权

链表的经典问题

单纯记录学习过程

定义一个结构体

typedef _ListNode *PtrToNode
struct _ListNode {
    int data;
    PtrToNode next;
};
typedef PtrToNode List;

1.如何判断两个单链表是否相交，如果相交，找出交点（两个链表都不存在环）

思路：设两个单链表的长度分别为L1、L2，（假设L1>L2），则(L1-L2)的值就是交汇之前两个链表的长度差；
因此，只有让更长的链表先走L1-L2步，然后两个链表开始一起走，如果某次走到一个相同的节点，该节点即为交点。

static int GetListLength(List T) 
{
    int n;
    for(n=0; T; n++) {
        T = T->next; 
    }   
    return n;
}
static List FindFirstCommonNode(List T1, List T2)
{
    int i;
    int n1 = GetListLength(T1);
    int n2 = GetListLength(T2);
    // T1 always own longer list
    if (n1 < n2) {
        return FindFirstCommonNode(T2, T1);
    }   
    for (i=0; i<n1-n2; i++) {
        T1 = T1->next;
    }   
    while (T1 && T1 != T2) {
        T1 = T1->next;
        T2 = T2->next;    
    }   
    return T1; 
}

2.判断一个链表是否有环，并找到环的入口点

思路：快慢指针
这个地方网上很多人解释 slow = Head开始有点困难，我的理解是这样的：两者相遇,设慢的指针走了 s ，那么快的指针走了 2s ，这里有两点要清楚：
1，这时候快的指针已经在环里至少转了1圈,
2，而慢的指针不可能转满了1圈。

  • 前面这一点比较好理解，他们正好在环入口相遇，也可能进入环的路程相对环比较大，快的指针在里面转了几圈才相遇。
  • 后面这一点难理解一点，假设两个指针在环的同一点出发，快的指针正好在转满一圈的时候与慢的指针相遇，所以在这个情况下不论慢的指针入环的时候快的指针在他前面还是后面，都会在一圈之内追上。

我们可以做一个简单的数学计算，设环的大小为r，快的指针在里面转了n圈就有：

2s = s+nr   
-----> 
 s=nr

这个关系可能看不出什么东西
再来一个关系，设慢的指针进入环之前的路程为x，进入环之后为y，(y<r前面提到过)

x+y=s

两者结合的得到：

x+y=nr 
x=nr-y

也就是说进入环之前的距离x 和 从环的入口开始转n圈 之间差了 y ，而这个y是两个指针相遇的地方，也就是快指针现在在的地方，在这个地方快指针如果改为1步1步的走，将会在入口和慢指针相遇。
换句话说，如果慢指针从头开始走，快指针从环的入口开始走，每次都是走1步，那么慢指针到达环的入口时，快指针已经转了n-1圈，第n圈还差y的距离到达入口。所以当我们把快指针放到两者相遇的地方，也就是离入口y的地方，他们正好在入口相遇。

static List FindLoopPort(List Head)  
{  
    List slow = Head; 
    List fast = Head;  
    // 找到相遇点
    while ( fast && fast->next ) {   
        slow = slow->next;  
        fast = fast->next->next;  
        if ( slow == fast ) break;  
    }   
    if (fast == NULL || fast->next == NULL)  
        return NULL;  
    // 找到环入口点
    slow = Head;  
    while (slow != fast)  
    {   
        slow = slow->next;  
        fast = fast->next;  
    }   
    return slow;  
}

3.求一个单链表（无环）的中间节点

思路:设置两个指针(fast, slow)，初始值都指向头节点，slow每次前进一步，fast每次前进二步，当fast走到末尾时，slow刚好指向中间节点。

4.假如链表长度为N，如何返回链表的倒数第K个结点

思路：用两个指针，指针P1先走K-1步，然后指针P2才开始走，当指针P1遍历完链表时，P2还剩K个结点没有遍历。

List FindLastKNode(List Head, int K)
{
    if (NULL == Head)
        return NULL;
    List T1 = Head;
    List T2 = Head;

    while (T1 && --K)
        T1 = T1->next;

    if (K)     // here, K must be 0
        return NULL;

    while (T1->next) {
        T1 = T1->next;
        T2 = T2->next;
    }

    return T2;
}

5.在O(1)时间删除链表结点

思路:可以知道其下一个结点是B=A->next，将结点B值拷贝给A，然后删除B即可。

6.如何反转一个单链表

思路1:改变next指针指向，后面元素指向前面元素

static List ReverseList(List Head)
{
     List pNode = Head;
     List pNext = NULL;
     List pPrev = NULL;

     while (pNode) {
          pNext = pNode->next;    
          if (NULL == pNext)     
               Head = pNode;
          pNode->next = pPrev;
          pPrev = pNode;
          pNode = pNext;
     }   

     return Head;
}

思路2:新建一个链表，头插法插入数据

List change(List L1)
{
	int flag =0;
	List p1 = (List)malloc(sizeof(struct Node));	
	p1->Next = NULL;
	List temp1 = p1;
	L1 = L1->Next;
	while(L1->Next != NULL){
		List temp_1 = (List)malloc(sizeof(struct Node));
		temp_1->Data = L1->Data;
		temp_1->Next = temp1->Next;
		temp1->Next = temp_1;
		L1 = L1->Next;
	}
	if(L1->Next == NULL){
		List temp = (List)malloc(sizeof(struct Node));
		temp->Data = L1->Data;
		temp->Next = temp1->Next;
		temp1->Next = temp;
	}
	return p1;
}

7.复杂链表的复制

思路

static void CloneNodes(ListNode *Head)
{
    ListNode *p = Head;
    while (p) {

        ListNode *pCloned = malloc(sizeof(ListNode));

        pCloned->data = p->data;
        pCloned->next = p->next;
        pCloned->other = NULL;

        p->next = pCloned;
        p = pCloned->next;
    }
}

static void ConnectNodes(ListNode *Head)
{
    ListNode *pCloned;
    ListNode *p = Head;

    while(p){

        pCloned = p->next;

        if (p->other) {
            pCloned->other = p->other->next;
        }

        p = pCloned->next;
    }
}

8.翻转部分链表

思路:按部分拆分链表，分别翻转每一部分。每一部分的第一个元素为部分尾元素，最后一个元素为头元素，往后部分的头元素接在上一部分的为尾元素之后

所以需要五个指针 ： 当前位置指针，部分模块头元素指针，部分模块尾元素指针，记录上一部分尾元素的指针，新的链表头指针

List RolloverList(List list, int k)
{
	int flag=0;
     if (k <= 1 || list == NULL) {
          return list;
     }
     List cur = list;      //指向链表的头节点
     List newHead = NULL;      //指向逆置后的链表
     List sectionHead = NULL;     //指向需要逆置部分的头节点
     List sectionTail = NULL;      //指向需要逆置部分的尾节点
     List prevsectionTail = NULL;    //指向部分尾节点的指针

     while (cur) {
          int count = k;    
          prevsectionTail = sectionTail;
          sectionTail = cur;
          while (count-- && cur != NULL) {
               List tmp = cur;
               cur = cur->Next;
               tmp->Next = sectionHead;   
               sectionHead = tmp;
          }

          if (flag == 0){
          	   flag=1;
               newHead = sectionHead;        
          }
          else{
               prevsectionTail->Next = sectionHead;
          }
     }
     sectionTail->Next = NULL;
     return newHead;
}

9.合并有序链表

思路:比较两个链表数据，数据大的向后移动一位

List Merge(List L1, List L2)
{
	List p = (List)malloc(sizeof(struct Node));	//带头结点的链表
	List p1 = L1->Next;
	List p2 = L2->Next;
	List p3 = p;
	while (NULL != p1 && NULL != p2){
		if (p1->Data <= p2->Data){
			p3->Next = p1;
			p3 = p3->Next;
			p1 = p1->Next;
		}
		else{
			p3->Next = p2;
			p3 = p3->Next;
			p2 = p2->Next;
		}
	}
	if (NULL == p1){
		p3->Next = p2;
	}
	if (NULL == p2){
		p3->Next = p1;
	}
	L1->Next = NULL;
	L2->Next = NULL;
	return p;
}

10.获取两个升序链表相同元素

void getSameElement(List L1,List L2)
{
	if(L1->Next != NULL){
		L1 = L1->Next;
	}
	
	if(L2->Next != NULL){
		L2 = L2->Next;
	}
	
	while(L1->Next != NULL && L2->Next != NULL){
		if(L1->Data > L2->Data){
			L2 = L2->Next;
		}
		else if(L2->Data > L1->Data){
			L1 = L1->Next;
		}
		else if(L2->Data == L1->Data){
			printf("%d ",L1->Data);
			L1 = L1->Next;
			L2 = L2->Next;
		}
	}
	
	if(L1->Next == NULL && L2->Next == NULL){
		if(L2->Data == L1->Data){
			printf("%d ",L1->Data);
		}
	}

	while(L1->Next != NULL){
		if(L1->Data>L2->Data){
			break;
		}
		else if(L2->Data>L1->Data){
			L1 = L1->Next;
		}
		else if(L2->Data==L1->Data){
            printf("%d ",L1->Data);
			break;
		}
	}

	while(L2->Next != NULL){
		if(L2->Data>L1->Data){
			break;
		}
		else if(L1->Data>L2->Data){
			L2 = L2->Next;
		}
		else if(L2->Data==L1->Data){
            printf("%d ",L1->Data);
			break;
		}
	}
}

11.删除倒数第k个元素

思路:让一个指针先走k，随后两个指针同时走

List dele_k(List L1,int k)
{
	List p1 = L1;
	List p2 = L1;
	List del_p;
	List head = L1;
	if(L1 == NULL){
		return head;
	}
	while(p1->Next != NULL && k>0){
		p1 = p1->Next;
		k--;
	}
	if(k>0 && p1->Next == NULL){
		return head;
	}
	else if(k == 0 &&  p1->Next != NULL){
		while(p1->Next != NULL){
			p1 = p1->Next;
			p2 = p2->Next;
		}
		del_p = p2->Next;
		p2->Next = p2->Next->Next;
		free(del_p);
	}
	else if(k == 0 &&  p1->Next == NULL){
		head = head->Next;
	}
	return head;
}

12.初始化链表

List Read(int n)
{
	List p = (List)malloc(sizeof(struct Node));		//带头结点的链表
	p->Next = NULL;
	List temp1 = p;
	for (int i = 0; i < n; i++){
		List temp = (List)malloc(sizeof(struct Node));
		scanf("%d", &temp->Data);
		temp1->Next = temp;
		temp1 = temp1->Next;
	}
	temp1->Next = NULL;						//链表结尾指向NULL
	return p;
}

13.遍历打印链表

void Print(List L)
{
	List temp = L->Next;
	if (NULL == temp){
		printf("空链表！");
	}
	while (NULL != temp){
		printf("%d ",temp->Data);
		temp = temp->Next;
	}
}

主函数，方便学习直接使用以上模块

int main()
{
    int n;
	List L1;
    scanf("%d", &n);
	L1 = Read(n);
	Print(L1);
	return 0;
}
xiaoc_19
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
十八道经典链表问题
04-06
经典链表问题，包含十八道题，包含递归问题等，是读懂链表的经典例题
Python链表小练习---删除链表的倒数第K个节点和旋转链表
Wangtuo1115的博客
06-12 572
1、删除链表的倒数第K个节点 题目描述： 给定一个链表: 1->2->3->4->5, 和 k = 2. 当删除了倒数第二个节点后，链表变为 1->2->3->5. 解题思路： 使用两个指针p，q，刚开始两个指针指向链表的头部 让q指针向后移动k个节点，p和q节点之间的举例保持为k p和q同时向后移动，直到q.next = None，此时p节点为删除节点的前一个节点 删除倒数第k个节点，p.next = p.next.next 实现代码如下： from Sing
手撕力扣之双指针【链表数组】：删除链表的倒数第N个节点、链表中倒数第k个节点、分隔链表、环形链表I、II、寻找重复数、颜色分类、最短无序连续子数组、和为s的连续正数序列、翻转字符串里的单词、验证回文串
weixin_39770712的博客
11-18 273
力扣019. 删除链表的倒数第N个节点 class Solution { public: ListNode* removeNthFromEnd(ListNode* head, int n) { ListNode* dummyHead = new ListNode(0); dummyHead->next = head; ListNode* slow = dummyHead; ListNode* fast = dummyHead;
【数据结构】10道经典面试题目带你玩转链表
C/C++领域,数据结构,linux,MySQl学习者
11-18 418
10道关于链表的经典面试题目:包含移除链表元素,反转链表,链表的中间结点,链表中倒数第K个结点,合并两个有序链表,链表分割,链表的回文结构,相交链表,环形链表,环形链表找入环点等题目的解题思路图解及完整解题代码.
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 6531
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
链表之十大经典面试题
weixin_64702703的博客
04-06 1213
快速学习链表面试题
链表相关问题的完整代码
07-06
链表相关问题的完整代码，包括测试类和关键代码： **0、将链表翻转** **1、判断链表是否有环** **2、寻找环的入口点** **3、计算环的节点数** **4、计算(有环)链表的节点数** **5、找出环中距任意一点最远的节点** *...
简单的关于c++链表问题
11-06
简单的C++链表问题，欢迎大家下载
双向链表-约瑟夫问题_双向链表约瑟夫问题_源码
10-02
我们利用双向链表，来解决从而实现约瑟夫问题
C++经典算法 双向链表
12-13
C++经典算法 双向链表 采用了结构体，链表的知识。
链表中的经典问题
扬帆起航
05-12 138
链表中的经典问题
10道经典链表面试题
xaiobit_hl的博客
05-18 3639
目录 1.删除链表中等于给定值val的所有节点 2.反转一个单链表 3.给定一个带有头结点head的非空单链表，返回链表的中间结点。如果有两个中间结点，则 返回第二个中间结点 4.输入一个链表，输出该链表中倒数第k个结点 5.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所 有节点组成的 6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的 结点之前 7. 链表的回文结构 8. 输入两个链表，找出它们.........
链表经典 10题
mu_tong_的博客
10-12 2178
链表10 道经典例题
Leetcode：链表刷题（7道经典题目）
一起加油~
03-22 1603
Leetcode：链表刷题 列出了一些关于链表的经典题目，并提供了对应的题解。主要是用C++实现的。对于使用其他语言的童鞋，可以很好的迁移过去。
【链表及其经典问题】
chenjunheaixuexi的博客
07-20 265
假设head节点距离环的起点为a，当慢指针走到环的起点时，快指针距离环的起点也为a，假设此时快指针正向距离环的起点为x，那么当快指针向前走2x步，慢指针走x步时，他们两个相遇。顺序遍历链表，将其中的节点依次存入哈希表中，如果要存入的节点已经存在于哈希表中，则说明有环，遍历结束。因为环的总长度为a+x，因此此时他们距离环的起点距离为a，与起始点到环起点的距离相同。如果链表有环，那么快慢指针一定会相遇，指向同一个节点，当向同一个节点时，遍历结束。链表中的每个节点，通过指针域的值，形成一个线性结构。...
链表经典问题汇总
vivi的技术博客
08-09 1万+
收集了一下链表常见的面试为题： 1、如何判断一个单链表有环 2、如何判断一个环的入口点在哪里 3、如何知道环的长度 4、如何知道两个单链表（无环）是否相交 5、如果两个单链表（无环）相交，如何知道它们相交的第一个节点是什么 6、如何知道两个单链
关于链表的一些经典问题以及相关面试题
Xucc_x的博客
04-01 1640
关于链表的基本操作以及常见操作大家可以移步 链表及相关函数实现 当然，链表除了这些基本操作之外，还有很多很有意思以及很有深度的问题，在这里，给大家介绍一些这方面的问题 逆序打印链表 不允许遍历链表，在pos节点前插入新节点 约瑟夫环问题求解 单链表逆置 单链表冒泡排序 将两个有序链表合并成一个有序链表 查找单链表的中间节点 寻找倒数第k个节点 删除倒数第k个节点 判断单链表是否带环...
【典例】链表经典题目合集
浮光掠影
02-04 5203
爷把鱼缸搬出来了好吧~
链表经典练习题
热门推荐
erwuhuoche的博客
04-16 2万+
链表经典练习题 一、从尾到头打印单链表 因为单链表是有指向的，前一节点只能指向下一节点，因此为了实现从尾到头打印链表可以使用一种非常简单的方法就是递归，先遍历再输出。 代码实现： void LinkListReversePrint(LinkNode* head){ 85 if(head == NULL){ 86 return;//空链表 8...
循环链表约瑟夫问题java
最新发布
12-28
循环链表约瑟夫问题是一个经典的问题，可以使用循环链表的数据结构来解决。下面是一个Java的解决方法的示例： ```java import java.util.LinkedList; public class JosephProblem { public int joseph(int n, int...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值