【算法】链表

反转链表

反转链表是指将单向链表的顺序逆转，即原本的链表方向由头节点指向尾节点，变为尾节点指向头节点。

在 JavaScript 中，可以通过修改节点的指针来实现链表反转。具体步骤如下：

1. 首先定义一个辅助变量 prev，用于保存上一个节点的引用，初始时将其置为 null。

2. 遍历链表，从头节点开始进行反转操作。在每一步迭代中，需要先保存当前节点的下一个节点的引用，以防断开链表。

3. 将当前节点的 next 指针指向 prev，完成反转操作。

4. 更新 prev 为当前节点，将当前节点前移，进入下一个节点。

5. 重复步骤 2-4，直到遍历完整个链表。

6. 最后将头节点指向反转后的尾节点，返回新的链表头节点（原尾节点）即可。

下面是一个具体的 JavaScript 代码示例，展示如何反转链表：

class ListNode {
  constructor(val, next) {
    this.val = val;
    this.next = next ? next : null;
  }
}

function reverseLinkedList(head) {
  let prev = null;
  let current = head;

  while (current !== null) {
    const next = current.next;
    current.next = prev;

    prev = current;
    current = next;
  }

  return prev;
}

// 示例用法
const node5 = new ListNode(5);
const node4 = new ListNode(4, node5);
const node3 = new ListNode(3, node4);
const node2 = new ListNode(2, node3);
const node1 = new ListNode(1, node2);

console.log('原链表:');
console.log(node1); // 1 -> 2 -> 3 -> 4 -> 5

const reversedHead = reverseLinkedList(node1);

console.log('反转后的链表:');
console.log(reversedHead); // 5 -> 4 -> 3 -> 2 -> 1

在上面的代码中，定义了一个 ListNode 类来表示链表节点，使用 reverseLinkedList 函数来实现链表的反转。首先，创建了一个链表节点的链式结构，然后打印原链表和反转后的链表。

注意，为了方便起见，我们创建的 ListNode 类中有一个可选的 next 参数，使节点的下一个指针可以根据需要指向另一个节点。在示例中，将链表的值和下一个节点都作为参数进行了初始化。

综上所述，通过使用反转链表方法，将给定的链表 [1,2,3,4,5] 反转成 [5,4,3,2,1] 的形式。

移除链表

在JavaScript中，移除链表是指从链表中删除特定节点或根据特定条件删除节点的操作。这可以包括删除链表的头节点、尾节点或者中间的某个节点。

具体的链表移除操作取决于你对链表的组织方式，例如单链表、双向链表等。下面以单链表为例，介绍几种常见的链表移除操作：

1. 移除头节点：将头节点的下一个节点作为新的头节点即可。例如，如果链表为 1 -> 2 -> 3 -> 4 -> 5，那么移除头节点后的链表为 2 -> 3 -> 4 -> 5。

2. 移除尾节点：需要遍历链表找到尾节点的前一个节点，将其 next 指针设置为 null，即断开尾节点与前一个节点的连接。例如，如果链表为 1 -> 2 -> 3 -> 4 -> 5，那么移除尾节点后的链表为 1 -> 2 -> 3 -> 4。

3. 移除指定节点：需要遍历链表找到待移除节点的前一个节点，将其 next 指针指向待移除节点的下一个节点，跳过待移除节点。例如，如果链表为 1 -> 2 -> 3 -> 4 -> 5，要移除值为 3 的节点，那么移除节点后的链表为 1 -> 2 -> 4 -> 5。

需要注意的是，在移除链表中的节点时，可能需要对特殊情况进行处理，例如链表为空或只包含一个节点的情况。此外，如果你使用的是双向链表或者其他类型的链表，移除操作的具体实现方式可能会有所不同。

class ListNode {
  constructor(val, next) {
    this.val = val;
    this.next = next ? next : null;
  }
}

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

  const dummy = new ListNode(-1);
  dummy.next = head;
  
  let prev = dummy;
  let current = head;

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

  return dummy.next;
}

// 示例用法
const node5 = new ListNode(5);
const node4 = new ListNode(4, node5);
const node3 = new ListNode(3, node4);
const node2 = new ListNode(2, node3);
const node1 = new ListNode(1, node2);

console.log('原链表:');
console.log(node1); // 1 -> 2 -> 3 -> 4 -> 5

const newValue = 3;
const newHead = removeElements(node1, newValue);

console.log(`删除值为 ${newValue} 的节点后的链表:`);
console.log(newHead); // 1 -> 2 -> 4 -> 5

在实际的代码中，可以使用循环或者递归的方式来实现链表的移除操作，具体取决于你的实现偏好和逻辑。使用指针操作链表的 next 指针来进行节点的移除。

交换链表

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

要实现两两交换链表中相邻的节点并返回交换后的链表头节点，可以使用递归的方式完成。递归的核心思想是递归地处理每对相邻节点，并将交换后的节点连接起来。具体步骤如下：

1. 首先处理特殊情况，即链表为空或只包含一个节点（或者没有需要交换的节点）的情况，直接返回原链表头节点。

2. 对于每对相邻节点 node1 和 node2，交换它们的位置：

   • 将 node2 的 next 指针指向 node1，完成 node2 向前的连接。
   • 将 node1 的 next 指针指向 node2.next（即下一对要交换的节点），完成 node1 向后的连接。

3. 递归调用交换后的节点 node2.next，即继续处理后面的节点对。

4. 返回交换后的链表头节点 node2。

下面是一个具体的 JavaScript 代码示例来交换链表中的相邻节点：

class ListNode {
  constructor(val, next) {
    this.val = val;
    this.next = next ? next : null;
  }
}

function swapPairs(head) {
  if (head === null || head.next === null) {
    return head;
  }

  const node1 = head;
  const node2 = head.next;

  node1.next = swapPairs(node2.next);
  node2.next = node1;

  return node2;
}

// 示例用法
const node4 = new ListNode(4);
const node3 = new ListNode(3, node4);
const node2 = new ListNode(2, node3);
const node1 = new ListNode(1, node2);

console.log('原链表:');
console.log(node1); // 1 -> 2 -> 3 -> 4

const newHead = swapPairs(node1);

console.log('交换后的链表:');
console.log(newHead); // 2 -> 1 -> 4 -> 3

在上面的代码中，定义了一个 ListNode 类来表示链表节点，使用 swapPairs 函数来交换链表中的相邻节点。示例中，创建了一个包含四个节点的链表，并打印了原链表和交换后的链表。

综上所述，通过使用递归方式和节点交换操作，可以两两交换链表中相邻的节点并返回交换后的链表头节点。请注意，在整个过程中是不修改节点内部的值的。

链表相交

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

要找出两个单链表的相交节点，可以使用双指针的方法。具体步骤如下：

1. 初始化两个指针 pA 和 pB，分别指向两个链表的头节点 headA 和 headB。

2. 同时遍历链表，当其中一个指针达到链表末尾时，将其重定位到另一个链表的头节点。

3. 当两个指针相遇时，即为相交节点的位置。如果链表有相交节点，则相交节点之后的节点都是相同的，因此两个指针在第一次相交时就会相等。

4. 如果两个链表没有相交节点，最终指针会同时到达各自链表的尾部，此时两个指针都为 null，返回 null。

下面是一个具体的 JavaScript 代码示例来找出两个单链表的相交节点：

class ListNode {
  constructor(val, next) {
    this.val = val;
    this.next = next ? next : null;
  }
}

function getIntersectionNode(headA, headB) {
  if (headA === null || headB === null) {
    return null;
  }

  let pA = headA;
  let pB = headB;

  while (pA !== pB) {
    pA = pA === null ? headB : pA.next;
    pB = pB === null ? headA : pB.next;
  }

  return pA;
}

// 为了构建示例，创建两个相交链表（从第三个节点开始相交）
const intersectNode = new ListNode(4, new ListNode(5));
const headA = new ListNode(1, new ListNode(2, intersectNode));
const headB = new ListNode(3, intersectNode);

console.log('链表A:');
console.log(headA); // 1 -> 2 -> 4 -> 5

console.log('链表B:');
console.log(headB); // 3 -> 4 -> 5

const intersection = getIntersectionNode(headA, headB);

console.log('相交节点:');
console.log(intersection); // 4 -> 5

在上面的代码中，定义了一个 ListNode 类来表示链表节点，使用 getIntersectionNode 函数来找出两个单链表的相交节点。示例中，创建了两个相交链表，并打印了链表A、链表B和相交节点。

综上所述，通过使用双指针遍历链表的方式，可以找出两个单链表相交的起始节点。如果两个链表没有交点，则返回 null。

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

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

要删除链表的倒数第 n 个节点并返回链表的头节点，可以使用快慢指针的方法。具体步骤如下：

1. 初始化两个指针 fast 和 slow，并将它们都指向链表的头节点。

2. 将 fast 指针向前移动 n+1 步，使得 fast 指针与 slow 指针之间相隔 n 个节点。

3. 同时移动 fast 和 slow 指针，直到 fast 指针到达链表的末尾（即 fast.next 为 null）。

4. 此时 slow 指针位于倒数第 n+1 个节点的位置，将其 next 指针指向下下个节点，即删除了倒数第 n 个节点。

5. 返回链表的头节点。

需要注意的是，如果要删除的是链表中的最后一个节点，即倒数第 n+1 个节点不存在，可以直接返回 head.next。

下面是一个具体的 JavaScript 代码示例来删除链表的倒数第 n 个节点：

class ListNode {
  constructor(val, next) {
    this.val = val;
    this.next = next ? next : null;
  }
}

function removeNthFromEnd(head, n) {
  const dummy = new ListNode(0); // 创建一个虚拟头节点
  dummy.next = head;

  let fast = dummy;
  let slow = dummy;

  // 将 fast 指针移动 n+1 步
  for (let i = 0; i <= n; i++) {
    fast = fast.next;
  }

  // 同时移动 fast 和 slow 指针直到 fast 到达末尾
  while (fast !== null) {
    fast = fast.next;
    slow = slow.next;
  }

  // 删除倒数第 n 个节点
  slow.next = slow.next.next;

  return dummy.next;
}

// 示例用法
const node4 = new ListNode(5);
const node3 = new ListNode(4, node4);
const node2 = new ListNode(3, node3);
const node1 = new ListNode(2, node2);
const head = new ListNode(1, node1);

console.log('原链表:');
console.log(head); // 1 -> 2 -> 3 -> 4 -> 5

const n = 2; // 倒数第 n 个节点，这里是 2
const newHead = removeNthFromEnd(head, n);

console.log(`删除倒数第 ${n} 个节点后的链表:`);
console.log(newHead); // 1 -> 2 -> 3 -> 5

在上面的代码中，定义了一个 ListNode 类来表示链表节点，使用 removeNthFromEnd 函数来删除链表的倒数第 n 个节点。示例中，创建了一个包含五个节点的链表，并打印了原链表和删除节点后的链表。

综上所述，通过使用快慢指针的方式，可以删除链表的倒数第 n 个节点并返回链表的头节点。

环形链表

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

要找到链表中环的起始节点，可以使用快慢指针的方法。具体步骤如下：

1. 使用快慢指针，初始化两个指针 slow 和 fast，都指向链表的头节点 head。

2. 同时移动 slow 和 fast 指针，其中 slow 指针每次移动一步，fast 指针每次移动两步，直到两个指针相遇。

3. 如果两个指针相遇，说明链表中有环，此时将 fast 指针重新指向头节点 head。

4. 接下来，让 fast 和 slow 指针每次都移动一步，直到两个指针再次相遇。相遇点即为环的起始节点。

5. 如果两个指针再次相遇，则说明链表中有环。返回相遇点作为环的起始节点。

6. 如果 fast 指针走到链表的尽头（fast 为 null），此时链表没有环，直接返回 null。

下面是一个具体的 JavaScript 代码示例来返回链表开始入环的第一个节点：

class ListNode {
  constructor(val, next) {
    this.val = val;
    this.next = next ? next : null;
  }
}

function detectCycle(head) {
  let slow = head;
  let fast = head;

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

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

  return null;
}

// 示例用法
const node4 = new ListNode(4);
const node3 = new ListNode(3, node4);
const node2 = new ListNode(2, node3);
const node1 = new ListNode(1, node2);
node4.next = node2; // 创建一个带环的链表

console.log('链表:');
console.log(node1); // 1 -> 2 -> 3 -> 4 -> 2 -> ...

const cycleStart = detectCycle(node1);

console.log('链表开始入环的第一个节点:');
console.log(cycleStart); // 2

在上面的代码中，定义了一个 ListNode 类来表示链表节点，使用 detectCycle 函数来返回链表开始入环的第一个节点。示例中，创建了一个带环的链表，并打印了链表和链表开始入环的第一个节点。

综上所述，通过使用快慢指针的方式，可以找出链表开始入环的第一个节点。如果链表中没有环，返回 null。