链表部分题目总结

力扣题目总结

链表

141. 环形链表

题目：

给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。 否则，返回 false 。

var hasCycle = function(head) {
    if (!head) return false
    let fast = head, slow = head
    while (fast && fast.next) {
        fast=fast.next.next
        slow=slow.next
        if (fast == slow) {
            return true
        }
    }
    return false
};

题解：

利用快慢指针的方式，令快指针一次走两步，慢指针一次走一步，如果它们最终相遇，则说明此链表一定存在环，如果一直都没有相遇，则说明，该链表不是环形链表，注意判断有效性

142. 环形链表II

题目：

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

**说明：**不允许修改给定的链表。

var detectCycle = function (head) {
  if (!head) return null;
  let fast = head,
    slow = head;
  while (fast && fast.next) {
    fast = fast.next.next;
    slow = slow.next;
    if (fast == slow) {
      let temp = head;
      while (temp != fast) {
        temp = temp.next;
        fast = fast.next;
        }
        return temp
    }
  }
  return null;
};

题解：

利用快慢指针的方式，令快指针一次走两步，慢指针一次走一步，如果它们最终相遇，则说明此链表一定存在环，如果一直都没有相遇，则说明，该链表不是环形链表，但在环形链表题目的基础之上，需要我们来指出具体的入环点，我们最后会找到规律，在两指针相遇的节点到入环点和从头指针到入环点的步数相同，则可以创建一个临时指针，让它为头指针，然后，让快慢指针中的任意一个指针与临时指针分别一次走一步，相遇的点则是入环点，返回即可

148. 排序链表

题目：

给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。

const merge = (head1, head2) => {
    const dummyHead = new ListNode(0);
    let temp = dummyHead, temp1 = head1, temp2 = head2;
    while (temp1 !== null && temp2 !== null) {
        if (temp1.val <= temp2.val) {
            temp.next = temp1;
            temp1 = temp1.next;
        } else {
            temp.next = temp2;
            temp2 = temp2.next;
        }
        temp = temp.next;
    }
    if (temp1 !== null) {
        temp.next = temp1;
    } else if (temp2 !== null) {
        temp.next = temp2;
    }
    return dummyHead.next;
}

const toSortList = (head, tail) => {
    if (head === null) {
        return head;
    }
    if (head.next === tail) {
        head.next = null;
        return head;
    }
    let slow = head, fast = head;
    while (fast !== tail) {
        slow = slow.next;
        fast = fast.next;
        if (fast !== tail) {
            fast = fast.next;
        }
    }
    const mid = slow;
    return merge(toSortList(head, mid), toSortList(mid, tail));
}

var sortList = function(head) {
    return toSortList(head, null);
};

const merge = (head1, head2) => {
    const dummyHead = new ListNode(0);
    let temp = dummyHead, temp1 = head1, temp2 = head2;
    while (temp1 !== null && temp2 !== null) {
        if (temp1.val <= temp2.val) {
            temp.next = temp1;
            temp1 = temp1.next;
        } else {
            temp.next = temp2;
            temp2 = temp2.next;
        }
        temp = temp.next;
    }
    if (temp1 !== null) {
        temp.next = temp1;
    } else if (temp2 !== null) {
        temp.next = temp2;
    }
    return dummyHead.next;
}

var sortList = function(head) {
    if (head === null) {
        return head;
    }
    let length = 0;
    let node = head;
    while (node !== null) {
        length++;
        node = node.next;
    }
    const dummyHead = new ListNode(0, head);
    for (let subLength = 1; subLength < length; subLength <<= 1) {
        let prev = dummyHead, curr = dummyHead.next;
        while (curr !== null) {
            let head1 = curr;
            for (let i = 1; i < subLength && curr.next !== null; i++) {
                curr = curr.next;
            }
            let head2 = curr.next;
            curr.next = null;
            curr = head2;
            for (let i = 1; i < subLength && curr != null && curr.next !== null; i++) {
                curr = curr.next;
            }
            let next = null;
            if (curr !== null) {
                next = curr.next;
                curr.next = null;
            }
            const merged = merge(head1, head2);
            prev.next = merged;
            while (prev.next !== null) {
                prev = prev.next;
            }
            curr = next;
        }
    }
    return dummyHead.next;
};

题解：

方法一：

归并排序(递归)

由图所知，先找到中点，然后分割，直到head->next为空或者是尾(切割)，则不用继续分割，分割递归结束，然后进行合并，合并可定义一个辅助节点，

让两个有序链表进行一一对比，哪个小，就让prev指向哪个节点，以此类推，直到两个链表有一方为空而结束，最后返回prev.next，则为最后排序好的链表

方法二：

归并排序(从底至顶直接合并)，由上图所知，使用自底向上的方法实现归并排序，则可以达到 O(1)O(1) 的空间复杂度。

首先求得链表的长度 \textit{length}length，然后将链表拆分成子链表进行合并。

具体做法如下。

用 \textit{subLength}subLength 表示每次需要排序的子链表的长度，初始时 \textit{subLength}=1subLength=1。

每次将链表拆分成若干个长度为 \textit{subLength}subLength 的子链表（最后一个子链表的长度可以小于 \textit{subLength}subLength），按照每两个子链表一组进行合并，合并后即可得到若干个长度为 \textit{subLength} \times 2subLength×2 的有序子链表（最后一个子链表的长度可以小于 \textit{subLength} \times 2subLength×2）。合并两个子链表仍然使用「21. 合并两个有序链表」的做法。

将 \textit{subLength}subLength 的值加倍，重复第 2 步，对更长的有序子链表进行合并操作，直到有序子链表的长度大于或等于 \textit{length}length，整个链表排序完毕。

如何保证每次合并之后得到的子链表都是有序的呢？可以通过数学归纳法证明。

初始时 \textit{subLength}=1subLength=1，每个长度为 11 的子链表都是有序的。

如果每个长度为 \textit{subLength}subLength 的子链表已经有序，合并两个长度为 \textit{subLength}subLength 的有序子链表，得到长度为 \textit{subLength} \times 2subLength×2 的子链表，一定也是有序的。

当最后一个子链表的长度小于 \textit{subLength}subLength 时，该子链表也是有序的，合并两个有序子链表之后得到的子链表一定也是有序的。

因此可以保证最后得到的链表是有序的。

202. 快乐数

题目：

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
• 如果 可以变为 1，那么这个数就是快乐数。

如果 n 是快乐数就返回 true ；不是，则返回 false 。

const getNext = function (n) {
  let sum = 0;
  while (n > 0) {
    sum += (n % 10) * (n % 10);
    n = Math.floor(n / 10);
  }
  return sum;
};
var isHappy = function (n) {
  let fast = n,slow = n;
    fast=getNext(getNext(fast))
    slow=getNext(slow)
  while (fast != slow && fast!=1) {
    fast=getNext(getNext(fast));
    slow=getNext(slow);
    }
    return fast==1
};
//如果不是快乐数，则应该是成环的，最终都是一直循环的，相当于一个成环的链表。
//如果是快乐数，则最终结果为1

题解：

先定义一个getext()方法，用来获取每个平方和的数，然后进行快乐数的判断，采取快慢指针的方式，来判断是环形的还是结尾为1的。

206. 反转链表

题目：

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

var reverseList = function (head) {
  if (!head) return null;
    let pre = null, cur = head, next = null
    
    while (cur) {
      next = cur.next;
      cur.next = pre
      pre = cur
      cur=next
  }
  return pre;
};

或

var reverseList = function (head) {
  if (!head) return null;
    let pre = null, cur = head
    while (cur) {
        [cur.next,pre,cur]=[pre,cur,cur.next]
    }
  return pre;
};

题解：

设置三个指针，注意只能一个一个传，所以不要丢失节点

92. 反转链表II

题目：

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

var reverseBetween = function(head, left, right) {
    if (!head) return null
    let ret = new ListNode(0, head)
    let pre=ret
    let count = right - left + 1
    //1
    while (--left) {
        pre=pre.next
    }
    pre.next = reverse(pre.next, count)
    return ret.next
    
};
var reverse = function (head, count) {
    let pre = null, cur = head, next = null
    while (count--) {
        next = cur.next
        cur.next = pre;
        pre = cur
        cur=next
    }
    head.next=cur
    return pre
}

题解：

在反转链表题目的基础上，设定了一个反转的范围，则需要找到pre,cur,next的位置，先创建一个虚头节点，再往前按–left移动，找到具体位置，反转

25. K个一组翻转链表

题目：

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

进阶：

• 你可以设计一个只使用常数额外空间的算法来解决此问题吗？
• 你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

var reverseKGroup = function (head, k) {
    if (!head) return null
    //虚拟头结点
    let ret = new ListNode(0, head)
    let pre = ret
    while (pre) {
         pre.next=reverse(pre.next,k)
        for (let i = 0; i < k && pre; i++){
            pre=pre.next
        }
        if(!pre) break
    }
    return ret.next 
};
//翻转操作
var reverse = function (head, n) {
    let pre = head, cur = head, count = n
    while (pre && --n) {
        pre=pre.next
    }
    if (!pre) {
        return head
    }
    pre = null
    //让pre哪都不指向，指向为空
    while (count--) {
        [cur.next,pre,cur]=[pre,cur,cur.next]
    }
    head.next = cur
    //此时cur.next已经没有值了，则把真实的head.next设置为当前的cur值
    return pre
}

61.旋转链表

题目：

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

var rotateRight = function(head, k) {
    if (!head) return null
    let size = 1;
    let pre=head
    while (pre && pre.next) {
        pre = pre.next
        size++
    }
    pre.next = head
    //成环
    for (let i = 0; i < size - (k % size) - 1; i++){
        head=head.next
    }
    pre = head.next //pre指向新的头结点
    head.next = null//将新的头结点与上一结点的指针断开
    return pre
};

题解：

1.先通过pre遍历指针，使pre到达此链表的尾结点（为了下一步成环），同时可以获得整个链表的长度(便于计算k>size时，少走一些没必要的步数，性能更好)

2.由于pre在尾结点处，则令其pre.next=head，则可以成环

3.成环后，我们需要让head指针走到新的头结点前个结点处，通过使用size和k，则找到此节点，然后pre=head.next得到新的头结点，然后断开head

19. 删除链表的倒数第n个结点

题目：

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

var removeNthFromEnd = function(head, n) {
    if (!head) return null
    let ret = new ListNode(0, head)
    let pre = ret;
    let cur = head
    while (n--) {
        cur=cur.next
    }
    while (cur ) {
        pre = pre.next
        cur=cur.next
    }
    pre.next = pre.next.next
    return ret.next
};

题解：

1. 首先定义一个虚拟头结点，和pre，cur指针，让cur从头结点head开始走，走完n步
2. 然后让pre和cur同步走，最后cur走完5到下一个节点发现为空即停止，而pre会正好走到要删除的结点的前一个结点，因为cur相当于走了size，而pre走了size-n，由图上的例子可得到，cur一共走了5步，而pre走了5-2=3步，到达"3"结点处，则令pre.next的指向改为pre.next.next，则3和5自动连上，由于指针是唯一指向性，所以4将没有结点指向它，时间久了，4结点会自动被垃圾回收。使用两个结点既可以保证结点不丢失，也可以找到规律，具体的倒数第n个结点的前一个位置

83. 删除排序链表中的重复元素

题目：

存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素 只出现一次 。

返回同样按升序排列的结果链表。

var deleteDuplicates = function(head) {
    if (!head) return null
    let cur = head //定义一个头指针cur，指向链表的头结点head
    while (cur && cur.next) {
        if (cur.val == cur.next.val) {
            cur.next=cur.next.next
        } else {
            cur=cur.next
        }
    }
    return head
};

题解：

1. 定义一个头指针cur，指向链表的头结点head
2. 如果当前指向节点的值和下一个节点的值相等，则令其下一个节点改为下一个节点的下一个节点，否则，就正常往下走，当遍历完整个链表之后，返回链表的头节点

82. 删除排序链表中的重复元素II

题目：

存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除链表中所有存在数字重复情况的节点，只保留原始链表中 没有重复出现 的数字。

返回同样按升序排列的结果链表。

var deleteDuplicates = function (head) {
  if (!head) return null;
  let vir = new ListNode(0, head);
  let pre = vir,
    cur = head;
  while (cur && cur.next) {
    if (pre.next.val != cur.next.val) {
      cur = cur.next;
      pre = pre.next;
    } else {
      while (cur && cur.next && pre.next.val == cur.next.val) {
        cur = cur.next;
      }
      pre.next = cur.next;
      cur = cur.next;
    }
  }
  return vir.next;
};

题解：

构建一个虚拟头节点，指向第一个节点head，定义一个pre指针指向虚拟头节点，定义一个cur指针指向head节点，它们一前一后，然后在有效的前提下，判断pre.next.val的值与cur.next.val的值是否相同，如果不同，则pre指针和cur指针分别向后移动一步，继续判断，假设出现了相同值的情况，pre不动，cur往后一直寻找一个与pre不同的节点值，进入一个新的循环，找到后，跳出循环，令pre指针跟上cur指针的步伐，还是原来的一前一后，继续判断值的情况，注意cur和cur.next的有效性，没到尾节点则一直按以上的判断执行，直到找不到有效节点为止跳出循环

1669. 合并两个链表

题目：

给你两个链表 list1 和 list2 ，它们包含的元素分别为 n 个和 m 个。

请你将 list1 中下标从 a 到 b 的全部节点都删除，并将list2 接在被删除节点的位置。

下图中蓝色边和节点展示了操作后的结果：

请你返回结果链表的头指针。

var mergeInBetween = function(list1, a, b, list2) {
    let cur = list1
    for (let i = 0; i < a - 1 && cur && cur.next; i++)
    {
        cur=cur.next    
    }
    let node=cur.next
    for (let i = a; i < b+1; i++)
    {
        node=node.next
    }
    cur.next = list2
    while (cur&&cur.next) {
        cur=cur.next
    }
    cur.next = node
    return list1
        
};

或

var mergeInBetween = function(list1, a, b, list2) {
    let ret = new ListNode(0, list1)
    let pre = ret
    let index=0
    let temp1 = list1
    let temp2=list2
    let total=b-a+1
    //令temp1指针指到a处，pre指到a-1处
    while (temp1 && temp1.next&&index!=a) {
        temp1 = temp1.next
        pre=pre.next
        index=index+1
    }
    //过滤a~b的节点
    while (total--) {
        temp1=temp1.next
    }
    pre.next = temp2
    while (pre && pre.next) {
        pre=pre.next
    }
    pre.next = temp1
    return ret.next
        
};

题解：

构建一个指向list1虚拟头节点，定义一个指向虚拟头节点的指针，然后，令这个指针指向虚拟头节点，则相当于连上list1，然后令pre找到a-1的位置，temp1找到a的位置，进行过滤，一直走到b+1的位置，可以保证后面的节点不丢失，然后令pre.next和list2连上，遍历list2，将pre.next指向temp1的位置，返回ret.next，则为最后链表

160. 相交链表

题目：

var getIntersectionNode = function (headA, headB) {
  if (!headA || !headB) return null;
  let p1 = headA,
    p2 = headB;
  while (p1 != p2) {
    p1 = p1 === null ? headB : p1.next;
    p2 = p2 === null ? headA : p2.next;
    }
    return p1
};

题解：