这个节点 class 如何在双向链表中工作

Question

在class Node中，next是Node类型或者null，这样我们只能将Node或者null赋值给next

class Node {
  value: any;
  next: Node | null;
  prev: Node | null;

  constructor(value: any) {
    this.value = value;
    this.next = null;
    this.prev = null;
  }
}

但我看到在推送 function 中，在“this.tail.;next = newNode”这一行中，我们只将 newNode 引用分配给 next 属性，这里 newNode 只是一个引用，它没有任何价值。 或下一个或上一个值，就像我们在 Node 类中一样。

push(value: any) {
    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++;
    return this;
  }

我真的无法理解，如何只给出一个类型为 Node 的 next 引用，而不是包含 value、next 和 prev 属性的 Node。

Answer 1

这里的newNode只是一个引用，它不会像我们在节点 class 中那样具有值、下一个或上一个值。

在 TypeScript 中，对象始终作为引用处理。 Node没有struct类型的变量，就像在 C 中那样。当在 TypeScript/JavaScript 中我们谈到“对象”时，可以推断我们处理的是引用。 点运算符实际上对应于 C 中的-> 。C 中的点运算符（用于struct变量）在 TypeScript/JavaScript 中没有对应项，因为它没有此类类型化变量。

newNode引用由构造函数初始化的 object，具有value 、 next和prev属性。

tail.next属性确实分配了一个引用，这是预期的。

例如，假设我们已经有一个列表，其中一个节点的值为 1，那么我们可以这样描绘它：

 list
  ↓
┌───────────┐   ┌────────────┐
│ head: ───────►│ prev: null │
│ tail: ───────►│ value: 0   │
│ length: 1 │   │ next: null │
└───────────┘   └────────────┘

如果现在list.push(2) ，我们首先使用new Node(2)运行Node构造函数，它初始化对象的属性，并返回 object （参考）分配给newNode ：

 list
  ↓
┌───────────┐   ┌────────────┐
│ head: ───────►│ prev: null │
│ tail: ───────►│ value: 0   │
│ length: 1 │   │ next: null │
└───────────┘   └────────────┘

                ┌────────────┐
                │ prev: null │
                │ value: 2   │
                │ next: null │
                └────────────┘
                   ↑
                 newNode

然后this.tail.;next = newNode; 将复制该参考：

 list
  ↓
┌───────────┐   ┌────────────┐
│ head: ───────►│ prev: null │
│ tail: ───────►│ value: 0   │
│ length: 1 │   │ next: ┐    │
└───────────┘   └───────│────┘
                        ▼
                ┌────────────┐
                │ prev: null │
                │ value: 2   │
                │ next: null │
                └────────────┘
                   ↑
                 newNode

和newNode.prev = this.tail; 处理相反方向的链接：

 list
  ↓
┌───────────┐   ┌────────────┐
│ head: ───────►│ prev: null │
│ tail: ───────►│ value: 0   │
│ length: 1 │   │ next: ┐    │
└───────────┘   └───────│────┘
                        ▼ ▲
                ┌─────────│──┐
                │ prev: ──┘  │
                │ value: 2   │
                │ next: null │
                └────────────┘
                   ↑
                 newNode

最后， this.tail = newNode; this.length++将完成操作：

 list
  ↓
┌───────────┐   ┌────────────┐
│ head: ───────►│ prev: null │
│ tail: ──────┐ │ value: 0   │
│ length: 1 │ │ │ next: ┐    │
└───────────┘ │ └───────│────┘
              │         ▼ ▲
              │ ┌─────────│──┐
              └►│ prev: ──┘  │
                │ value: 2   │
                │ next: null │
                └────────────┘
                   ↑
                 newNode