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

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

* Update mindmap

* Reduce the size of the mindmap.png

codes/java/chapter_heap/my_heap.java

@@ -18,23 +18,23 @@ class MaxHeap {
     public MaxHeap(List<Integer> nums) {
         // 将列表元素原封不动添加进堆
         maxHeap = new ArrayList<>(nums);
-        // 堆化除叶结点以外的其他所有结点
+        // 堆化除叶节点以外的其他所有节点
         for (int i = parent(size() - 1); i >= 0; i--) {
             siftDown(i);
         }
     }
 
-    /* 获取左子结点索引 */
+    /* 获取左子节点索引 */
     private int left(int i) {
         return 2 * i + 1;
     }
 
-    /* 获取右子结点索引 */
+    /* 获取右子节点索引 */
     private int right(int i) {
         return 2 * i + 2;
     }
 
-    /* 获取父结点索引 */
+    /* 获取父节点索引 */
     private int parent(int i) {
         return (i - 1) / 2; // 向下整除
     }
@@ -65,21 +65,21 @@ class MaxHeap {
 
     /* 元素入堆 */
     public void push(int val) {
-        // 添加结点
+        // 添加节点
         maxHeap.add(val);
         // 从底至顶堆化
         siftUp(size() - 1);
     }
 
-    /* 从结点 i 开始，从底至顶堆化 */
+    /* 从节点 i 开始，从底至顶堆化 */
     private void siftUp(int i) {
         while (true) {
-            // 获取结点 i 的父结点
+            // 获取节点 i 的父节点
             int p = parent(i);
-            // 当“越过根结点”或“结点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无需修复”时，结束堆化
             if (p < 0 || maxHeap.get(i) <= maxHeap.get(p))
                 break;
-            // 交换两结点
+            // 交换两节点
             swap(i, p);
             // 循环向上堆化
             i = p;
@@ -91,9 +91,9 @@ class MaxHeap {
         // 判空处理
         if (isEmpty())
             throw new EmptyStackException();
-        // 交换根结点与最右叶结点（即交换首元素与尾元素）
+        // 交换根节点与最右叶节点（即交换首元素与尾元素）
         swap(0, size() - 1);
-        // 删除结点
+        // 删除节点
         int val = maxHeap.remove(size() - 1);
         // 从顶至底堆化
         siftDown(0);
@@ -101,18 +101,18 @@ class MaxHeap {
         return val;
     }
 
-    /* 从结点 i 开始，从顶至底堆化 */
+    /* 从节点 i 开始，从顶至底堆化 */
     private void siftDown(int i) {
         while (true) {
-            // 判断结点 i, l, r 中值最大的结点，记为 ma
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
             int l = left(i), r = right(i), ma = i;
             if (l < size() && maxHeap.get(l) > maxHeap.get(ma))
                 ma = l;
             if (r < size() && maxHeap.get(r) > maxHeap.get(ma))
                 ma = r;
-            // 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
             if (ma == i) break;
-            // 交换两结点
+            // 交换两节点
             swap(i, ma);
             // 循环向下堆化
             i = ma;