javascript/js實現 排序二叉樹數據結構 學習隨筆

二叉樹是一種數據結構。其特點是：

1.由一系列節點組成，具有層級結構。每個節點的特性包含有節點值、關系指針。節點之間存在對應關系。

2.樹中存在一個沒有父節點的節點，叫做根節點。樹的末尾存在一系列沒有子節點的節點，稱為葉子節點。其他可以叫做中間節點。

3.樹的根節點位於第一層，層級數越大，節點位置越深，層級數也叫做樹高。

排序二叉樹為二叉樹的一種類型，其特點是：

1.節點分為左右子樹。

2.在不為空的情況下，左子樹子節點的值都小於父節點的值。

3.在不為空的情況下，右子樹子節點的值都大於父節點的值。

4.每個節點的左右子樹都按照上述規則排序。

如圖：

（打錯字了..）

js代碼來實現上述數據結構：

1.節點用對象來描述，節點特性用對象屬性來描述。

class Node {
  constructor(key) {
    this.key = key;// 節點值
    this.left = null;// 左指針
    this.right = null;// 右指針
  }
}

2.二叉樹結構用對象來描述。

// 二叉樹
class BinaryTree {
  constructor() {
    this.root = null;// 根節點
  }
  insert(key) {// api--插入
    const newNode = new Node(key);
    if (this.root === null) {// 設置根節點  9       this.root = newNode;
    }
    method.insertNode(this.root, newNode);
  }
}

相關方法：

// method
method = {
  insertNode(root, newNode) {
    if (newNode.key < root.key) {// 進入左子樹
      if (root.left === null) {// 左子樹為空
        root.left = newNode;
      } else {// 左子樹已存在
        method.insertNode(root.left, newNode);
      }
    } else if (newNode.key > root.key) {// 進入右子樹
      if (root.right === null) {// 右子樹為空
        root.right = newNode;
      } else {// 右子樹已存在
        method.insertNode(root.right, newNode);
      }
    }
  }
};

具體用法：

// 實例化二叉樹
const binaryTree = new BinaryTree();

// key值
const keys = [19, 8, 15, 24, 45, 12, 5];

// 生成排序二叉樹
keys.forEach(key => binaryTree.insert(key));

結果：

 

排序二叉樹的遍歷：

 一、中序遍歷

（1）以上圖為例，中序遍歷順序為： 5 - 8 - 12 - 15 - 19 - 24 - 45。

（2）總是先遍歷左子樹，然后訪問根節點，接着遍歷右子樹。

代碼實現：

class BinaryTree {
  ...
  // callback為訪問節點時執行的操作
  inorderTraversal(callback) {// api--中序遍歷
    method.inorderTraversalNode(this.root, callback);
  }
}

method = {
  ...

  inorderTraversalNode(node, callback) {
    if (node) {// 當前節點
      method.inorderTraversalNode(node.left, callback);// 遍歷左子樹
      callback(node);// 訪問節點
      method.inorderTraversalNode(node.right, callback);// 遍歷右子樹
    }
  },
};

// 中序遍歷
binaryTree.inorderTraversal(node => console.log(node.key));

// key值
const keys = [19, 8, 15, 24, 45, 12, 5];

輸入結果：5 - 8 - 12 - 15 - 19 - 24 - 45

二、前序遍歷

（1）以上圖為例，前序遍歷順序為： 19 - 8 - 5 - 15  - 12 - 24 - 45。

（2）總是先訪問根節點，然后遍歷左子樹，接着遍歷右子樹。

代碼實現：

class BinaryTree {
  ...    
  preOrderTraversal(callback) {// api--前序遍歷
    method.preOrderTraversalNode(this.root, callback);
  }
}

method = {
  ... 
  preOrderTraversalNode(node, callback) {
    if (node) {// 當前節點
      callback(node);// 訪問節點
      method.preOrderTraversalNode(node.left, callback);// 遍歷左子樹
      method.preOrderTraversalNode(node.right, callback);// 遍歷右子樹
    }
  }
};

// 前序遍歷
binaryTree.preOrderTraversal(node => console.log(node.key));

// key值
const keys = [19, 8, 15, 24, 45, 12, 5];

輸入結果：19 - 8 - 5 - 15  - 12 - 24 - 45

三、后序遍歷

（1）以上圖為例，后序遍歷順序為： 5 - 12 - 15 - 8  - 45 - 24 - 19。

（2）先遍歷左子樹，接着遍歷右子樹，最后訪問根節點。

代碼實現：

class BinaryTree {
  ...   
  postOrderTraversal(callback) {// api--后序遍歷
    method.postOrderTraversalNode(this.root, callback);
  }
}

method = {
  ...
  postOrderTraversalNode(node, callback) {
    if (node) {// 當前節點
      method.postOrderTraversalNode(node.left, callback);// 遍歷左子樹
      method.postOrderTraversalNode(node.right, callback);// 遍歷右子樹
      callback(node);// 訪問節點
    }
  }
};

// 后序遍歷
binaryTree.postOrderTraversal(node => console.log(node.key));

// key值
const keys = [19, 8, 15, 24, 45, 12, 5];

輸入結果：5 - 12 - 15 - 8  - 45 - 24 - 19

排序二叉樹的查找：

（1）查找最大值。根據排序二叉樹的特點，右子樹的值都大於父節點的值。只需要進入節點的右子樹查找，當某個節點的右子樹為空時，該節點就是最大值節點。

代碼實現：

class BinaryTree {
  ...
  max() {
    return method.maxNode(this.root);
  }
}

method = {
  ...
  maxNode(node) {
    if (node) {
      while(node.right !== null) {// 右子樹不為空時 13         node = node.right;
      }
      return node.key;
    }
    return null;
  }
};

// key值
const keys = [19, 8, 15, 24, 45, 12, 5];

結果：

（2）查找最小值。根據排序二叉樹的特點，左子樹的值都小於父節點的值。只需要進入節點的左子樹查找，當某個節點的左子樹為空時，該節點就是最小值節點。

代碼實現：

 1 class BinaryTree {
 2   ...
 3   min() {
 4     return method.minNode(this.root);
 5   }
 6 }
 7 
 8 method = {
 9   ...
10   minNode(node) {
11     if (node) {
12       while(node.left!== null) {// 左子樹不為空時
13         node = node.left;
14       }
15       return node.key;
16     }
17     return null;
18   }
19 };

// key值
const keys = [19, 8, 15, 24, 45, 12, 5];

結果：

（3）查找給定值。在排序二叉樹中查找有沒有節點對應的值與給定值相同。

根據排序二叉樹的特點，比較給定值與節點值，小於時進入節點左子樹。大於時進入節點右子樹。等於時返回真。層層對比，最后如果子樹為空，則表示沒有找到。

代碼實現：

class BinaryTree {
  ...
  search(key) {
    return method.searchNode(this.root, key);
  }
}

method = {
  ...
  searchNode(node, key) {
    if (node === null) {// 沒有找到 12       return false;
    }
    if (key < node.key) {// 進入左子樹 15       return method.searchNode(node.left, key);
    } else if (key > node.key) {// 進入右子樹 17       return method.searchNode(node.right, key);
    } else {// 找到了 19       return true;
    }
  }
};

// key值
const keys = [19, 8, 15, 24, 45, 12, 5];

結果：

排序二叉樹的刪除：

當刪除的節點為葉子節點時，直接把葉子節點設置成空。如圖：刪除值為5的節點。

原：                                                                                                                                     

          

 現：

當刪除的節點存在左子樹時，把父節點的關系指針直接指向左子樹。如圖：刪除值為15的節點。存在右子樹時同理。

原：                                                                                                                                      

        

現：

  

當節點存在左右子樹時，先去右子樹里找到最小值，然后用最小值替換節點值，最后進入右子樹刪除最小值對應的節點。如圖：刪除值為8的節點。

原：                                                                                                                                      

     

現：

   

代碼實現：

class BinaryTree {
  ...
  remove(key) {
    this.root = method.removeNode(this.root, key);
  }
}

method = {
  ...   
  removeNode(node, key) {
    if(node === null) {// 沒有找到值對應的節點
      return null;
    }
    if (key < node.key) {// 給定值小於當前節點值
      node.left = method.removeNode(node.left, key);
      return node;
    } else if (key > node.key) {// 給定值大於當前節點值
      node.right = method.removeNode(node.right, key);
      return node;
    } else {// 找到給定值對應的節點
      if (node.left === null && node.right === null) {// 節點為葉子節點
        node = null;
        return node;
      }

      if (node.left === null) {// 節點存在右子樹
        node = node.right;
        return node;
      } else if (node.right === null) {// 節點存在左子樹
        node = node.left;
        return node;
      }

      // 節點存在左右子樹時，先去右子樹里找到最小值，然后用最小值替換節點值，最后進入右子樹刪除最小值對應的節點。
      const minKey = method.minNode(node.right);
      node.key = minKey;
      method.removeNode(node.right, minKey);
      return node;
    }
  }
};

結果：

累死我了。。。