淺談排序二叉樹

前言：

大學時代，已過去一年多了，數據結構是咱們最懼怕的課，也是我最喜歡的課，曾經有個plan畢業了研究算法，可是世事難料，最後本身的人生軌跡偏向了遊戲行業。

最近不知道那根筋不對，就是想回首，再看看二叉樹，如下是個人一些看法，歡迎你們指正！

 

咱們工做中，使用最多的就是排序二叉樹（不必定是平衡二叉樹哦）

如下代碼，包含了，二叉樹的建立，前序遍歷，中序遍歷，後續遍歷，查找最大值，查找最小值，查找特定值，刪除特定值（子節點，只有右孩子的節點，只有左孩子的節點，擁有左右子樹的節點）

  1 var binaryTree = function(){
  2 
  3     var createNode = function(key){
  4         this.key = key;
  5         this.left = null;
  6         this.right = null;
  7     }
  8 
  9 
 10     var insertNode = function(node, newNode){
 11         if(newNode.key < node.key){
 12             if(node.left === null){
 13                 node.left = newNode;
 14             }else{
 15                 insertNode(node.left, newNode);
 16             }
 17         }else{
 18             if(node.right === null){
 19                 node.right = newNode;
 20             }else{
 21                 insertNode(node.right, newNode);
 22             }
 23         }
 24     }
 25 
 26 
 27     var root = null;
 28     this.createTree = function(key){
 29         var newNode = new createNode(key);
 30         if(root === null){
 31             root = newNode;
 32         }else{
 33             insertNode(root, newNode);
 34         }
 35     }
 36 
 37 
 38 
 39 
 40     // 中序遍歷: 輸出升序的數組
 41     var inorderTraversalNode = function(node){
 42         if(node !== null){
 43             inorderTraversalNode(node.left);
 44             console.log(node.key);
 45             inorderTraversalNode(node.right);
 46         }
 47     }
 48 
 49 
 50     // 前序遍歷：高效複製一個二叉樹（On）
 51     var preTraversalNode = function(node){
 52         if(node !== null){
 53             console.log(node.key);
 54             preTraversalNode(node.left);
 55             preTraversalNode(node.right);
 56         }
 57     }
 58 
 59 
 60     // 後序遍歷：文件系統的遍歷
 61     var postTraversalNode = function(node){
 62         if(node !== null){
 63             preTraversalNode(node.left);
 64             preTraversalNode(node.right);
 65             console.log(node.key);
 66         }
 67     }
 68 
 69 
 70     // type 1:前序
 71     // type 2:中序
 72     // type 3:後序
 73     this.traversal = function(type){
 74         switch(type){    
 75             case 1:
 76                 preTraversalNode(root);
 77                 break;
 78             case 2:
 79                 inorderTraversalNode(root);
 80                 break;
 81             case 3:
 82                 postTraversalNode(root)
 83                 break;
 84         }
 85     }
 86 
 87 
 88     var minNode = function(node){
 89         if(node){
 90             if(node.left){
 91                 return minNode(node.left);
 92             }else{
 93                 return node.key;
 94             }
 95         }
 96         return null;
 97     }
 98     this.min = function(){
 99         return minNode(root);
100     }
101 
102 
103 
104     var maxNode = function(node){
105         if(node){
106             if(node.right){
107                 return maxNode(node.right)
108             }else{
109                 return node.key;
110             }
111             return null;
112         }
113     }
114     this.max = function(){
115         return maxNode(root);
116     }    
117 
118 
119     var searchNode = function(node, key){
120         if(node){
121             if(key < node.key){
122                 return searchNode(node.left, key);
123             }else if(key > node.key){
124                 return searchNode(node.right, key);
125             }else{
126                 return true;
127             }
128         }
129         return false;
130     }
131     this.search = function(key){
132         return searchNode(root, key);
133     }    
134 
135     var findMinNode = function(node){
136         if(node){
137             if(node.left){
138                 return findMinNode(node.left);
139             }else{
140                 return node;
141             }
142         }
143         return null;
144     }
145     var removeNode = function(node, key){
146         if(node){
147             if(key < node.key){
148                 node.left = removeNode(node.left, key);
149                 return node;
150             }else if(key > node.key){
151                 node.right = removeNode(node.right, key);
152                 return node;
153             }else{
154                 if(node.left === null && node.right === null){
155                     node = null;
156                     return node;
157                 }else if(node.left === null){
158                     node = node.right;
159                     return node;
160                 }else if(node.right === null){
161                     node = node.left;
162                     return node;
163                 }else{
164                     var aux = findMinNode(node.right);
165                     node.key = aux.key;
166                     node.right = removeNode(node.right, aux.key);
167                     return node;
168                 }
169             }
170         }
171     }
172     this.remove = function(key){
173         root = removeNode(root, key)
174     }
175 }
176 
177 
178 var tree = new binaryTree();
179 var arr = [4, 2, 12, 10, -7, 21, 3, 99, 76];
180 for(var i = 0; i < arr.length; i ++){
181     tree.createTree(arr[i]);
182 }
183 
184 tree.traversal(2);
185 console.log('The tree minNode key is ' + tree.min());
186 console.log('The tree maxNode key is ' + tree.max());
187 console.log(tree.search(12) ? 'The key is 12 is found' : 'The key is 12 is not found');
188 console.log(tree.search(11) ? 'The key is 11 is found' : 'The key is 11 is not found');