数据结构入门链表篇-CSDN博客

本文链接：https://blog.csdn.net/dai_qingyun/article/details/122711250

141. 环形链表

给你一个链表的头节点 head ，判断链表中是否有环。

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

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

示例：输入：head = [3,2,0,-4], pos = 1，输出：true。

第一种解法：「利用哈希表记录遍历过程中的链表节点，如果存在环，则会存在当前节点已经被记录过」。

时间复杂度：O(n)，空间复杂度：O(n)。

const hasCycle = head => {
  const record = new Set();

  while (head) {
    if (record.has(head)) {
      return true;
    }
    record.add(head);
    head = head.next;
  }

  return false;
}

第二种解法：「利用快慢指针技巧，如果链表中存在环，则快指针在某个时间点一定会和慢指针相遇，否则会提前到达链表的终点」。

时间复杂度：O(n)，空间复杂度：O(1)。

const hasCycle = head => {

  if (!head || !head.next) {
    return false;
  }

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

  while (slow !== fast) {
    if (!fast || !fast.next) {
      // 到达终点
      return false;
    }

    slow = slow.next;
    fast = fast.next.next;
  }

  return true;
}

21. 合并两个有序链表

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：输入：l1 = [1,2,4], l2 = [1,3,4]，输出：[1,1,2,3,4,4]。

第一种解法：「由于两个链表是有序的，所以可以采用双指针进行归并操作」。

时间复杂度 O(n)，空间复杂度 O(1)。

const mergeTwoLists = function(list1, list2) {
    const head = new ListNode(-1);
    let current = head;

    while (list1 && list2) {
        if (list1.val <= list2.val) {
            current.next = list1;
            list1 = list1.next;
        } else {
            current.next = list2;
            list2 = list2.next;
        }

        current = current.next;
    }

    current.next = list1 ? list1 : list2;

    return head.next;
};

第二种解法：「上述双指针归并的迭代操作，同样可以转化为递归方式求解，当list1或者list2为空时递归结束」。

时间复杂度 O(m + n)，空间复杂度 O(m + n)。

const mergeTwoLists = function(list1, list2) {
    if (!list1) {
        return list2;
    } else if (!list2) {
        return list1;
    } else if (list1.val <= list2.val) {
        list1.next = mergeTwoLists(list1.next, list2);
        return list1;
    } else {
        list2.next = mergeTwoLists(list1, list2.next);
        return list2;
    }
};

203. 移除链表元素

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

示例：输入：head = [1,2,6,3,4,5,6], val = 6，输出：[1,2,3,4,5]。

第一种解法：「利用递归在每一段链表中需要合适的后继节点，当前节点为空时，则终止递归」。

时间复杂度：O(n)，空间复杂度：O(n)。

const removeElements = function(head, val) {
  if (!head) {
    return null;
  }

  head.next = removeElements(head.next, val);
  return head.val === val ? head.next : head;
};

第二种解法：「利用迭代替换递归，但是这里需要注意使用 dummyHead 制造一个头节点，因为原链表中的头节点也是有可能被删除掉的」。

时间复杂度：O(n)，空间复杂度：O(n)。

const removeElements = (head, val) => {
  const dummyHead = new ListNode(-1, head);
  let current = dummyHead;

  while (current.next) {
    if (current.next.val === val) {
      current.next = current.next.next;
    } else {
      current = current.next;
    }
  }

  return dummyHead.next;
}

206. 反转链表

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

示例：输入：head = [1,2,3,4,5]，输出：[5,4,3,2,1]。

迭代解法：「遍历的过程中将当前节点的next指针指向前一个节点」。

时间复杂度：O(n)，空间复杂度：O(1)。

const reverseList = head => {
  let prev = null;
  let current = head;
  while (current) {
    const next = current.next;
    current.next = prev;
    prev = current;
    current = next;
  }

  return prev;
}