每日算法题【链表】：相交链表、环形链表、环形链表II

(13)输入两个链表，找出它们的第一个公共结点

• [160. 相交链表 - 力扣（LeetCode）]:

• 解题思路：

  相交链表：两个链表只要相交，其尾结点一定相同，否则就不相交。
  求交点：长的链表先走（长度差）步，再同时走，第一个相同的就是交点。

  /**
  * Definition for singly-linked list.
  * struct ListNode {
  *     int val;
  *     struct ListNode *next;
  * };
  */
  
  struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
     struct ListNode* tailA = headA;
     struct ListNode* tailB = headB;
     //遍历两个链表，得到节点数和尾结点
     int lenA = 1;
     while(tailA->next){
         ++lenA;
         tailA = tailA->next;
     }
  
     int lenB = 1;
     while(tailB->next){
         ++lenB;
         tailB = tailB->next;
     }
     //遍历到最后尾节点不相同则不相交
     if(tailA != tailB){
         return NULL;
     }
  
     int gap = abs(lenA - lenB);
  
     //长的先走差距步，在同时往后走找交点
     struct ListNode* longList = headA;
     struct ListNode* shortList = headB;
  
     if(lenA < lenB){
         shortList = headA;
         longList = headB;
     }
  
     while(gap--){
         longList = longList->next;
     }
  
     while(longList != shortList){
         longList = longList->next;
         shortList = shortList->next;
     }
  
     return longList;
  }
  

(14)判断是否为环形链表

• [141. 环形链表 - 力扣（LeetCode）]:

• 解题思路：

  首先，我们申请两个指针，一个是快指针fast（一次走两步），一个是慢指针slow（一次走一步）。

  其次，我们让两个指针向前遍历，会有两种情况。

  链表不成环，那么快指针fast就会走向空NULL。
  链表如果成环，快指针一次走两步，慢指针一次走一步。那么两个指针的距离会越来越小直至相遇。此时证明了链表成环。

  /**
   * Definition for singly-linked list.
   * struct ListNode {
   *     int val;
   *     struct ListNode *next;
   * };
   */
  bool hasCycle(struct ListNode *head) {
      //定义快慢指针指向链表头结点
      struct ListNode* Fast = head;
      struct ListNode* Slow = head;
  
      //当快指针遍历一遍没有指向空，说明链表带环
      while(Fast && Fast->next)//Fast && Fast->next都不能为空，因为Fast一次要走两步
      {
          //快指针一次走两步，慢指针一次走一步
          Fast = Fast->next->next;
          Slow = Slow->next;
          if(Fast == Slow){
              return true;
          }
      }
      return false;
  }
  

(15)返回环形链表的第一个节点

• [142. 环形链表 II - 力扣（LeetCode）]:

• 解题思路：

  首先，我们申请两个指针，一个是快指针fast（一次走两步），一个是慢指针slow（一次走一步）。

  其次，我们让两个指针向前遍历，当两指针相遇时，在相遇点放置一个相遇指针meet，然后通过循环，meet指针在相遇点走，head指针在头节点走，两指针相遇时，此点即为入环的第一个结点。

  /**
   * Definition for singly-linked list.
   * struct ListNode {
   *     int val;
   *     struct ListNode *next;
   * };
   */
  struct ListNode *detectCycle(struct ListNode *head) {
      //定义快慢指针指向链表头结点
      struct ListNode* Fast = head;
      struct ListNode* Slow = head;
  
      //当快指针遍历一遍没有指向空，说明链表带环
      while(Fast && Fast->next)//Fast && Fast->next都不能为空，因为Fast一次要走两步
      {
          //快指针一次走两步，慢指针一次走一步
          Fast = Fast->next->next;
          Slow = Slow->next;
          if(Fast == Slow){
              //再相遇点设置一个meet指针
              struct ListNode* meet = Fast;
              while(head != meet){
                  //并且让meet和head同时往后走，相遇时就是入环节点
                  head = head->next;
                  meet = meet->next;
              }
              return head;
          }
      }
      return NULL;
  }