refactor: Replace 结点 with 节点 (#452)

* Replace 结点 with 节点
Update the footnotes in the figures

* Update mindmap

* Reduce the size of the mindmap.png

codes/javascript/chapter_heap/my_heap.js

@@ -14,23 +14,23 @@ class MaxHeap {
     constructor(nums) {
         // 将列表元素原封不动添加进堆
         this.#maxHeap = nums === undefined ? [] : [...nums];
-        // 堆化除叶结点以外的其他所有结点
+        // 堆化除叶节点以外的其他所有节点
         for (let i = this.#parent(this.size() - 1); i >= 0; i--) {
             this.#siftDown(i);
         }
     }
 
-    /* 获取左子结点索引 */
+    /* 获取左子节点索引 */
     #left(i) {
         return 2 * i + 1;
     }
 
-    /* 获取右子结点索引 */
+    /* 获取右子节点索引 */
     #right(i) {
         return 2 * i + 2;
     }
 
-    /* 获取父结点索引 */
+    /* 获取父节点索引 */
     #parent(i) {
         return Math.floor((i - 1) / 2); // 向下整除
     }
@@ -61,20 +61,20 @@ class MaxHeap {
 
     /* 元素入堆 */
     push(val) {
-        // 添加结点
+        // 添加节点
         this.#maxHeap.push(val);
         // 从底至顶堆化
         this.#siftUp(this.size() - 1);
     }
 
-    /* 从结点 i 开始，从底至顶堆化 */
+    /* 从节点 i 开始，从底至顶堆化 */
     #siftUp(i) {
         while (true) {
-            // 获取结点 i 的父结点
+            // 获取节点 i 的父节点
             const p = this.#parent(i);
-            // 当“越过根结点”或“结点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无需修复”时，结束堆化
             if (p < 0 || this.#maxHeap[i] <= this.#maxHeap[p]) break;
-            // 交换两结点
+            // 交换两节点
             this.#swap(i, p);
             // 循环向上堆化
             i = p;
@@ -85,9 +85,9 @@ class MaxHeap {
     pop() {
         // 判空处理
         if (this.isEmpty()) throw new Error("堆为空");
-        // 交换根结点与最右叶结点（即交换首元素与尾元素）
+        // 交换根节点与最右叶节点（即交换首元素与尾元素）
         this.#swap(0, this.size() - 1);
-        // 删除结点
+        // 删除节点
         const val = this.#maxHeap.pop();
         // 从顶至底堆化
         this.#siftDown(0);
@@ -95,18 +95,18 @@ class MaxHeap {
         return val;
     }
 
-    /* 从结点 i 开始，从顶至底堆化 */
+    /* 从节点 i 开始，从顶至底堆化 */
     #siftDown(i) {
         while (true) {
-            // 判断结点 i, l, r 中值最大的结点，记为 ma
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
             const l = this.#left(i),
                 r = this.#right(i);
             let ma = i;
             if (l < this.size() && this.#maxHeap[l] > this.#maxHeap[ma]) ma = l;
             if (r < this.size() && this.#maxHeap[r] > this.#maxHeap[ma]) ma = r;
-            // 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
             if (ma == i) break;
-            // 交换两结点
+            // 交换两节点
             this.#swap(i, ma);
             // 循环向下堆化
             i = ma;