双向链表：LeetCode上一个有趣的设计挑战

前端

2023-09-11 01:48:19

双向链表：一种强大的数据结构

在我们的技术之旅中，我们已经探索了单链表的领域，它以其简洁和高效而著称。今天，让我们深入了解一个更高级的数据结构——双向链表，它为单链表的功能增添了额外的反向遍历能力。

双向链表的优势

双向链表结合了单链表的优点，还提供了以下独特的优势：

双向遍历： 与只能向前遍历的单链表不同，双向链表允许我们同时向前和向后遍历链表，这在某些情况下非常方便。
快速插入和删除： 由于双向链表中的每个节点都与它的前一个和后一个节点相连，因此在链表中间插入或删除节点变得非常高效。
环状链表的创建： 双向链表可以轻松地连接成环，从而创建环状链表，这在某些算法和数据结构中非常有用。

双向链表的实现

在 JavaScript 中，我们可以使用以下代码片段实现一个简单的双向链表：

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
    this.prev = null;
  }
}

class DoublyLinkedList {
  constructor() {
    this.head = null;
    this.tail = null;
    this.length = 0;
  }

  // 添加节点到链表尾部
  append(value) {
    const newNode = new Node(value);
    if (this.length === 0) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode;
      newNode.prev = this.tail;
      this.tail = newNode;
    }
    this.length++;
  }

  // 从链表头部删除节点
  removeHead() {
    if (this.length === 0) {
      return null;
    }
    const removedNode = this.head;
    if (this.length === 1) {
      this.head = null;
      this.tail = null;
    } else {
      this.head = this.head.next;
      this.head.prev = null;
    }
    this.length--;
    return removedNode.value;
  }

  // 从链表尾部删除节点
  removeTail() {
    if (this.length === 0) {
      return null;
    }
    const removedNode = this.tail;
    if (this.length === 1) {
      this.head = null;
      this.tail = null;
    } else {
      this.tail = this.tail.prev;
      this.tail.next = null;
    }
    this.length--;
    return removedNode.value;
  }

  // 在指定位置插入节点
  insertAt(index, value) {
    if (index < 0 || index > this.length) {
      throw new Error("Invalid index");
    }
    if (index === 0) {
      this.append(value);
    } else if (index === this.length) {
      this.prepend(value);
    } else {
      const newNode = new Node(value);
      const currentNode = this.getNodeAt(index);
      const previousNode = currentNode.prev;
      previousNode.next = newNode;
      newNode.prev = previousNode;
      newNode.next = currentNode;
      currentNode.prev = newNode;
      this.length++;
    }
  }

  // 从指定位置删除节点
  removeAt(index) {
    if (index < 0 || index >= this.length) {
      throw new Error("Invalid index");
    }
    if (index === 0) {
      return this.removeHead();
    } else if (index === this.length - 1) {
      return this.removeTail();
    } else {
      const removedNode = this.getNodeAt(index);
      const previousNode = removedNode.prev;
      const nextNode = removedNode.next;
      previousNode.next = nextNode;
      nextNode.prev = previousNode;
      this.length--;
      return removedNode.value;
    }
  }

  // 获取指定位置的节点
  getNodeAt(index) {
    if (index < 0 || index >= this.length) {
      throw new Error("Invalid index");
    }
    let currentNode = this.head;
    for (let i = 0; i < index; i++) {
      currentNode = currentNode.next;
    }
    return currentNode;
  }
}