力扣链表类题目复盘及解法

一、链表基础知识

每一个节点由两部分组成，数据域（data）和指针域（存放指向下一个节点的指针next）。

即：head -> A(data+next) -> B(data+next) -> null

这一种链表又被称为单链表。

除此之外，还有双链表和循环链表。

双链表的每一个节点都有两个指针域（prev和next），因此其既能指向前一个也能指向后一个。

而循环链表为，每一个节点的指针域总是指向下一个节点的数据域，且链表首尾相连。

二、题目

1、单链表

203. 移除链表元素

题目：

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

提示：

• 列表中的节点数目在范围 [0, 104] 内
• 1 <= Node.val <= 50
• 0 <= val <= 50

示例：

解题思路：

/**
 * @param {ListNode} head
 * @param {number} val
 * @return {ListNode}
 */
var removeElements = function(head, val) {
    const ret = new ListNode(0, head);

    let cur = ret;

    while(cur.next) {
        if(cur.next.val === val){
            cur.next = cur.next.next; // 如果下一个节点的值和val一样，则这一个节点的next指针指向下一个节点
        }else {
            cur = cur.next; // 如果不等于，则继续指向下一个节点
        }
    }
    return ret.next;
};

2、双指针

206. 反转链表

题目：

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

提示：

• 链表中节点的数目范围是 [0, 5000]
• -5000 <= Node.val <= 5000

示例：

解题思路：

定义两个指针pre和cur，先用tmp把原本方向的下一个节点数存起来，再将cur指向原本方向的上一个节点以翻转指针，最后一一移动pre、cur的方向，往原本方向的右边移动一格。

/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
    if(!head || !head.next) return head;

    let cur = head, pre = null, tmp = null;
    while(cur) {
        tmp = cur.next;
        cur.next = pre;
        pre = cur;
        cur = tmp;
    }
    return pre;
    
};

24. 两两交换链表中的节点

题目：

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

提示：

• 链表中节点的数目在范围 [0, 100] 内
• 0 <= Node.val <= 100

示例：

解题思路：

/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var swapPairs = function(head) {
   let ret = new ListNode(0, head), temp = ret;

   while(temp.next && temp.next.next){
      let cur = temp.next.next, pre = temp.next;

      pre.next = cur.next; // 1的指针域指向3
      cur.next = pre; // 2的指针域指向1
      temp.next = cur; // 临时存储值的指针域指向
      temp = pre; // 临时存储值的指针域值
   }
   return ret.next;
};

19. 删除链表的倒数第N个节点

题目：

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

提示：

• 链表中结点的数目为 sz
• 1 <= sz <= 30
• 0 <= Node.val <= 100
• 1 <= n <= sz

示例：

解题思路：

/**
 * @param {ListNode} head
 * @param {number} n
 * @return {ListNode}
 */
var removeNthFromEnd = function(head, n) {
    let ret = new ListNode(0, head);

    let slow = fast = ret;
    while(n--) {
        fast = fast.next;
    }

    while(fast.next){
        slow = slow.next;
        fast = fast.next;
    }

    slow.next = slow.next.next;

    return ret.next;
};

142. 环形链表Ⅱ

题目：

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

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。

注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

提示：

• 链表中节点的数目范围在范围 [0, 104] 内
• -105 <= Node.val <= 105
• pos 的值为 -1 或者链表中的一个有效索引

示例：

解题思路：

利用双指针，fast指针每次走两格，slow指针每次走一格。如果最后fast == slow，说明它们在环内相遇。在相遇的点，slow指针返回head，两指针均走动一格，再次相遇时，此时为环的入口。

/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var detectCycle = function(head) {
    if(!head || !head.next) return null;

    let fast = head.next.next, slow = head.next;

    while(fast && fast.next && fast!=slow) {
        fast = fast.next.next;
        slow = slow.next;
    } 

    if(!fast || !fast.next) return null;
    slow = head;
    while(fast !== slow) {
        slow = slow.next;
        fast = fast.next;
    }
    return slow;
};