141. 环形链表+ 142. 环形链表 II + 160. 相交链表

141. 环形链表

环形链表

一、哈希表

将遍历遇到的节点均放在一个集合当中，用哈希表的目的是可以去重，即一个链表当中可能有重复的元素，从而误判存在环。如果存在环，那么集合中会出现相同的元素。

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
var hasCycle = function(head) {
    let set = new Set()

    while(head){
        if(set.has(head)){
            return true
        }else{
            set.add(head)
        }
        head = head.next
    }
    return false
};

二、快慢指针

思想：设置快慢指针，如果链表中存在环，那么快指针会提前进入环，并且一直在环当中。慢指针会稍后进去环，但是快慢指针由于前进的速度不一样，所以一定会在环中相遇。

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
var hasCycle = function(head) {
    if(!head || !head.next) return false

    let pre = head, cur = head.next;

    // 遍历链表,快指针走两步，慢指针走一步
    while(cur && cur.next){
        pre = pre.next
        cur = cur.next.next

        if(pre == cur) return true  
    }
    return false
};

142. 环形链表 II

题目链接

一、哈希表

类似141.环形链表的实现，只是将重合的节点打印出来。

var detectCycle = function(head) {
    // 定义一个哈希表，用来存储节点
    var set = new Set();
    
    // 遍历链表，当链表里没有的时候，就插入到哈希表中。即将整个链表都放入哈希表中
    while(head){
        if(!(set.has(head))){
            set.add(head);           
        }else{
            // 如果哈希表里存在，就证明有环,返回下标
            return head; 
        }
        head = head.next;
    }
    return null;
};

二、快慢指针

1. 快指针和慢指针都指向头部，慢指针一次移动一个，快指针一次移动两个。
2. 当第一次相遇的时候，让其中一个指针指向head,然后以相同的步调进行移动。 第二次相遇的位置就是环的起点

var detectCycle = function(head) {
    let fast = slow = head;
    // 第一次相遇
    while (fast && fast.next) {
        fast = fast.next.next;
        slow = slow.next;
        if (fast === slow) break;
    }
    // 判断fast是否为空
    if (!fast || !fast.next) {
        return null;
    }
    // 让slow重新指向head.这里需要注意循环条件，不能是上面的条件，因为第二次遍历的时候，指针有可能相遇，但是不是环的起点
    slow = head
    while (slow != fast) {
        fast = fast.next;
        slow = slow.next;
    }
    return slow;
};

160. 相交链表

160.相交链表
这一题和141.环形链表解法相同

一、哈希表

1、思想

比较节点相同，不仅仅是只比较里面的val值。往哈希表里面存的是节点而不是节点值。所以才会导致示例1的结果。故即便是值相等，也不代表节点相等。是否相等只能通过代码计算知道。

2、代码实现

var getIntersectionNode = function(headA, headB) {
    // 使用一个哈希表去存储链表A的所有节点
    var hash = new Set();
     
    // 遍历链表A，其中headA和headB指的都是头节点，不是指针
    while( headA != null){
        // 存储的是节点的地址而不是值
        hash.add(headA);
        headA = headA.next;
    }
    
    // 遍历链表B，检查链表B中的每个元素是否在哈希表中
    while(headB != null){
        if(hash.has(headB)){
            // 如果存在，则返回相交的起始节点
            return headB;
        }
        headB = headB.next;
    }
    // 遍历结束，没有相交的节点
    return null;       
};

3、算法分析

二、双指针

将空间复杂度降低

1、思想

双指针实现的思想 – 图解

2、代码实现

var getIntersectionNode = function(headA, headB) {
    // 判断其中链表为空的情况,空链表没有相交的节点
    if(!headA || !headB) return null;
    
    // 使用两个指针进行遍历。两个头节点另外的作用
    let pA = headA,pB = headB;
    
    // 开始遍历，遍历结束的条件是pA=pB
    while(pA != pB){
        
        // 链表A移动指针,当第一次遍历结束指向空的时候，就移动到链表B的开头
        if(pA != null){
            pA = pA.next;
        }else{
            pA = headB;
        }
        
         // 链表A移动指针,当第一次遍历结束指向空的时候，就移动到链表B的开头
        if(pB != null){
            pB = pB.next;
        }else{
            pB = headA;
        }      
    }
    // 返回的是最后相交的节点
    return pA;
};

3、算法分析