Javascript中的變數更新-有解無憂

我正在學習鏈接串列，并正在尋找這個解決方案來解決問題：

   /**
   * Definition for singly-linked list.
   * function ListNode(val, next) {
   *     this.val = (val===undefined ? 0 : val)
   *     this.next = (next===undefined ? null : next)
   * }
   */
   /**
   * @param {ListNode} list1
   * @param {ListNode} list2
   * @return {ListNode}
   */
   var mergeTwoLists = function(list1, list2) {
      let list = new ListNode();
      let head = list;
      console.log("first", head);
      while (list1 && list2) {
          if (list1.val <= list2.val) {
              list.next = list1;
              console.log("second", head);
              list1 = list1.next;
          } else {
              list.next = list2;
              list2 = list2.next;
          }
          list = list.next;
      }
      console.log("third", head, list);
      return head.next;
   };

有一件事我無法理解。所以，“頭”被設定為跟蹤“串列”。他們到底怎么會有不同的價值觀？

uj5u.com熱心網友回復：

首先，“head”存盤第一個節點地址。當“list”通過將不同的節點地址傳遞給“list”來沿著鏈表移動時，結果是它們最終不同。“頭”或“串列”只是一個地址容器，因此它們不會一直相同。如果它們存盤相同的地址，則它們相同。

uj5u.com熱心網友回復：

let head = list;

在上面的陳述句中，變數 head 保存了串列的當前值，并不是對串列的參考。

while (list1 && list2) {
      if (list1.val <= list2.val) {
          list.next = list1;
          console.log("second", head);
          list1 = list1.next;
      } else {
          list.next = list2;
          list2 = list2.next;
      }
      list = list.next;
  }

在上面的回圈中，每次迭代串列的值都會改變，它不會影響頭部的值。

因此，最后，由于head保存初始地址，它列印整個值串列，并且list列印串列的當前值（最后一個節點）。

見上圖 Javascript 中的變數更新

這里頭 -> [5, 7, 2, 15] 串列 -> [15]

uj5u.com熱心網友回復：

所以，“頭”被設定為跟蹤“串列”。他們到底怎么會有不同的價值觀？

原因是它head在第一次初始化之后永遠不會被分配任何其他東西，而在回圈中list 被分配了其他東西。list最初是參考與相同的（虛擬）節點head，但后來通過list = list.next重復執行來開始參考不同的節點。

這可能有助于形象化。假設我們合并兩個串列，其值分別為 1, 4 和 2, 3：

首先我們進行初始化。就在回圈開始之前，我們有這種情況：

head list
  ↓   ↓
┌───────────┐
│ val:  0   │
│ next:null │
└───────────┘

list1
  ↓
┌───────────┐   ┌───────────┐
│ val:  1   │   │ val:  4   │
│ next: ──────? │ next:null │
└───────────┘   └───────────┘

┌───────────┐   ┌───────────┐
│ val:  2   │   │ val:  3   │
│ next: ──────? │ next:null │
└───────────┘   └───────────┘
  ↑
list2

在回圈的第一次迭代中，第一個if條件為真，因此list.next = list1被執行。這導致以下情況：

head list
  ↓   ↓
┌───────────┐
│ val:  0   │
│ next: ─┐  │
└────────│──┘
         │
list1    │ 
  ↓      ▼
┌───────────┐   ┌───────────┐
│ val:  1   │   │ val:  4   │
│ next: ──────? │ next:null │
└───────────┘   └───────────┘

┌───────────┐   ┌───────────┐
│ val:  2   │   │ val:  3   │
│ next: ──────? │ next:null │
└───────────┘   └───────────┘
  ↑
list2

list1下一條陳述句為with分配不同的節點參考list1 = list1.next：

head list
  ↓   ↓
┌───────────┐
│ val:  0   │
│ next: ─┐  │
└────────│──┘
         │
         │      list1
         ▼        ↓
┌───────────┐   ┌───────────┐
│ val:  1   │   │ val:  4   │
│ next: ──────? │ next:null │
└───────────┘   └───────────┘

┌───────────┐   ┌───────────┐
│ val:  2   │   │ val:  3   │
│ next: ──────? │ next:null │
└───────────┘   └───────────┘
  ↑
list2

回圈第一次迭代中的最后一條陳述句，移動list參考， with ，list = list.next這意味著不再參考同一個節點；他們將永遠不再是相同的參考：headlist

head
  ↓
┌───────────┐
│ val:  0   │
│ next: ─┐  │
└────────│──┘
         │
list     │      list1
  ↓      ▼        ↓
┌───────────┐   ┌───────────┐
│ val:  1   │   │ val:  4   │
│ next: ──────? │ next:null │
└───────────┘   └───────────┘

┌───────────┐   ┌───────────┐
│ val:  2   │   │ val:  3   │
│ next: ──────? │ next:null │
└───────────┘   └───────────┘
  ↑
list2

在回圈的第二次迭代中，我們進入 else 塊，在那里我們設定list.next = list2：

head
  ↓
┌───────────┐
│ val:  0   │
│ next: ─┐  │
└────────│──┘
         │
list     │      list1
  ↓      ▼        ↓
┌───────────┐   ┌───────────┐
│ val:  1   │   │ val:  4   │
│ next: ─┐  │   │ next:null │
└────────│──┘   └───────────┘
         ▼
┌───────────┐   ┌───────────┐
│ val:  2   │   │ val:  3   │
│ next: ──────? │ next:null │
└───────────┘   └───────────┘
  ↑
list2

那么list1 = list1.next會導致：

head
  ↓
┌───────────┐
│ val:  0   │
│ next: ─┐  │
└────────│──┘
         │
list     │      list1
  ↓      ▼        ↓
┌───────────┐   ┌───────────┐
│ val:  1   │   │ val:  4   │
│ next: ─┐  │   │ next:null │
└────────│──┘   └───────────┘
         ▼
┌───────────┐   ┌───────────┐
│ val:  2   │   │ val:  3   │
│ next: ──────? │ next:null │
└───────────┘   └───────────┘
                  ↑
                 list2

同樣，第二次迭代的最后一條陳述句將移動list：

head
  ↓
┌───────────┐
│ val:  0   │
│ next: ─┐  │
└────────│──┘
         │
         │      list1
         ▼        ↓
┌───────────┐   ┌───────────┐
│ val:  1   │   │ val:  4   │
│ next: ─┐  │   │ next:null │
└────────│──┘   └───────────┘
         ▼
┌───────────┐   ┌───────────┐
│ val:  2   │   │ val:  3   │
│ next: ──────? │ next:null │
└───────────┘   └───────────┘
  ↑               ↑
list            list2

所以這個程序還在繼續，......從來沒有在head移動，而是list在移動。當回圈退出時，情況將是這樣的：

head
  ↓
┌───────────┐
│ val:  0   │
│ next: ─┐  │
└────────│──┘
         │
         │                 list1 == null
         ▼
┌───────────┐   ┌───────────┐
│ val:  1   │   │ val:  4   │
│ next: ─┐  │   │ next:null │
└────────│──┘   └───────────┘
         ▼                ▲
┌───────────┐   ┌─────────│─┐
│ val:  2   │   │ val:  3 │ │
│ next: ──────? │ next: ──┘ │
└───────────┘   └───────────┘
                  ↑        
                list       list2 == null

回傳值是head.next，它確實是對合并串列的第一個節點（值為 1）的參考。

我希望這能澄清它。

轉載請註明出處，本文鏈接：https://www.uj5u.com/shujuku/504663.html

標籤：javascript 变量链表

上一篇：如何在一個之后添加一個HTML元素并在另一個之前完成

下一篇：使用媒體查詢在小螢屏上切換列順序