判断链表是否有环及两链表是否相交

单向链表是最常用的数据结构之一,因此总结其常见的问题及其解决方案是很有意义的。

问题1:如何判断一个单向链表是否有环?如果有,如何找到其入口节点的指针?

算法思想:用两个指针p1,p2同时指向链表的头部,p1一次移动一步,p2一次移动两步,如果最终p1和p2重合则说明链表有环,如果p2走到空指针(链表的结尾)则说明链表无环; 如果最终p1和p2重合,使p2重新指向链表的头结点,然后p1和p2同时一次移动一步,当p1和p2再次重合时该节点指针就是环的入口节点指针。

算法实现:

[cpp] view plain copy

print?

  1. struct Node
  2. {
  3. int value;
  4. Node *next;
  5. };
  6. /*判断链表是否有环,如果有环则返回环的首结点指针,否则返回NULL值*/
  7. Node* findCircle(Node *head)
  8. {
  9. if(head==NULL)
  10. return NULL;
  11. Node *p1=head;
  12. Node *p2=head;
  13. /*判断链表是否有环,当p1=p2时说明链表有环,程序跳出循环。如果p2一直走到链表尽头则说明没有环。*/
  14. do{
  15. if(p1->next!=NULL&&p2->next!=NULL&&p2->next->next!=NULL)
  16. {
  17. p1=p1->next;
  18. p2=p2->next->next;
  19. }
  20. else
  21. return NULL;
  22. }
  23. while(p1!=p2);
  24. /*求出环的起点节点,并将其返回*/
  25. p2=head;
  26. while(p1!=p2)
  27. {
  28. p1=p1->next;
  29. p2=p2->next;
  30. }
  31. return p1;
  32. }

问题2:假定两个单向链表均无环。如何判定该两个链表相交?如果相交,如何找到首个相交点的指针?

算法思想:判断两个单向链表是否相交,有两个方法:一是利用其充要条件,即,相交的充要条件是两个链表最后一个表元为同一表元;二是将第二个链表接在第一个链表后面,然后判断第一个链表是否有环,如果有,则他们必然相交,否则不相交。   如何找到相交的首个节点呢?其实也就是第一个链表的环的入口节点。

算法实现:

[cpp] view plain copy

print?

  1. struct Node
  2. {
  3. int value;
  4. Node *next;
  5. };
  6. /*判断两个链表是否交叉,如果交叉返回交叉节点,否则返回NULL。*/
  7. Node* findCross(Node* head1,Node* head2)
  8. {
  9. if(head1==NULL||head2==NULL)
  10. return NULL;
  11. /*将第二个链表变成有环链表*/
  12. Node* tail2=head2;
  13. while(tail2->next!=NULL)
  14. tail2=tail2->next;
  15. tail2->next = head2;
  16. Node* temp = findCircle(head1);
  17. if(temp!=NULL)
  18. return temp;
  19. else
  20. return NULL;
  21. }

注意:上面两个例子中,均默认有哑节点,即head代表哑节点。

时间: 2024-10-10 13:55:47

判断链表是否有环及两链表是否相交的相关文章

判断单链表是否有环的两种方法(转)

如图,如果单链表有环,则在遍历时,在通过6之后,会重新回到3,那么我们可以在遍历时使用两个指针,看两个指针是否相等. 方法一:使用p.q两个指针,p总是向前走,但q每次都从头开始走,对于每个节点,看p走的步数是否和q一样.如图,当p从6走到3时,用了6步,此时若q从head出发,则只需两步就到3,因而步数不等,出现矛盾,存在环方法二:使用p.q两个指针,p每次向前走一步,q每次向前走两步,若在某个时候p == q,则存在环. #include <stdio.h> #include <st

判断单链表是否有环的两种方法

如图,如果单链表有环,则在遍历时,在通过6之后,会重新回到3,那么我们可以在遍历时使用两个指针,看两个指针是否相等. 方法一:使用p.q两个指针,p总是向前走,但q每次都从头开始走,对于每个节点,看p走的步数是否和q一样.如图,当p从6走到3时,用了6步,此时若q从head出发,则只需两步就到3,因而步数不等,出现矛盾,存在环 方法二:使用p.q两个指针,p每次向前走一步,q每次向前走两步,若在某个时候p == q,则存在环. 代码如下: 1 #include <stdio.h> 2 #inc

leetcode链表--14、add-two-numbers(两链表相加 得到新链表)

题目描述 You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list. Input: (2 -> 4 -> 3) + (5 -> 6 -

判断单向链表是否有环,环起点,环长,链表长

今天在微信上看到一篇介绍如何判断单向链表是否有环的文章,感觉很有意思,整理一下读后的思路. 一.判断单向链表是否有环 方法1:设置一个Hashset,顺序读取链表中的节点,判断Hashset中是否有该节点的唯一标识(ID).如果在Hashset中,说明有环:如果不在Hashset中,将节点的ID存入Hashset. 这种方法时间复杂度已经最优,但是因为额外申请了Hashset,所以空间复杂度不算最优. 方法2:设置2个指针,指向头节点.第1个指针每次指向下一个节点:第2个指针指向下一个节点的下一

【数据结构】28、判断链表是否有环

因为最近小米电话面试被问到如何判断一个链表是否有环,那今天正好实现以下这个算法 1.链表 package y2019.Algorithm.LinkedList; /** * @ProjectName: cutter-point * @Package: y2019.Algorithm.LinkedList * @ClassName: FindRing * @Author: xiaof * @Description: 现在存在一条链表,寻找这个链表是否存在环 * @Date: 2019/6/24 9

判断一个链表是否有环的几种方法

一.单链表是否有环 思路分析: 单链表有环,是指单链表中某个节点的next指针域指向的是链表中在它之前的某一个节点,这样在链表的尾部形成一个环形结构.判断链表是否有环,有以下几种方法. 1 // 链表的节点结构如下 2 typedef struct node 3 { 4 int data; 5 struct node *next; 6 } NODE; (1)最常用方法:定义两个指针,同时从链表的头节点出发,一个指针一次走一步,另一个指针一次走两步.如果走得快的指针追上了走得慢的指针,那么链表就是

检测一个链表是否有环

  定义两个指针fast.slow,其中,fast是快指针,slow是慢指针,二者的初始值都指向链表头, slow每次前进一步,fast每次前进两步,两个指针同时向前移动,快指针每移动一次都要跟慢指针比较,直到快指针等于慢指针为止,就证明了这个链表是带环的单向链表. 否则,这个是不带环的链表(fast先行到达尾部为NULL,则为无环链表). 代码: public boolean IsLoop(Node head)  //判断是否有环的函数 { Node fast = head; Node slo

如何判断单链表是否存在环 &amp; 判断两链表是否相交

给定一个单链表,只给出头指针h: 1.如何判断是否存在环? 2.如何知道环的长度? 3.如何找出环的连接点在哪里? 4.带环链表的长度是多少? 解法: 1.对于问题1,使用追赶的方法,设定两个指针slow.fast,从头指针开始,每次分别前进1步.2步.如存在环,则两者相遇:如不存在环,fast遇到NULL退出. 2.对于问题2,记录下问题1的碰撞点p,slow.fast从该点开始,再次碰撞所走过的操作数就是环的长度s. 3.问题3:有定理:碰撞点p到连接点的距离=头指针到连接点的距离,因此,分

笔试,面试,C/C++,判断单链表是否带环?若带环,求环长度,求环入口点(两种方法)

SListNode* IsRing(SListNode *&pHead) //判断链表是否有环,求相聚点 {  //判空.有.没有  //思路:两个指针从头开始一快(2步)一慢(1步),若最后可以相聚,则链表有环  if (pHead)  {   SListNode *fast = pHead;   SListNode *slow = pHead;   while (fast&&fast->next)   {    fast = fast->next->next;