这两天看了关于二叉树的知识点，把敲的demo记录下，方便后面查看 

  1 <!DOCTYPE html>
  2 <html>
  3 <head>
  4     <title>二叉树插入数据实现</title>
  5 </head>
  6 <body>
  7 <script type="text/javascript">
  8     function erchashu(){
  9         var node = function(key){
 10             this.key = key;
 11             this.left = null;
 12             this.right = null;
 13         } 
 14         var inseterNode = function(node,newNode){
 15             if(newNode.key < node.key){
 16                 if(node.left == null){
 17                     node.left = newNode;
 18                 }else{
 19                     inseterNode(node.left,newNode);
 20                 }
 21             }else{
 22                 if(node.right == null){
 23                     node.right = newNode;
 24                 }else{
 25                     inseterNode(node.right,newNode);
 26                 }
 27             }
 28         }
 29         var root = null;
 30         this.inseter = function(key){
 31             var newNode = new node(key);
 32             if(root == null){
 33                 root = newNode;
 34             }else{
 35                 inseterNode(root,newNode);
 36             }
 37         };
 38         //中序遍历，按照升序排序出二叉树的数值
 39         var inOrderTraverseNode = function(node,callBack){
 40             if(node !== null){
 41                 inOrderTraverseNode(node.left,callBack);
 42                 callBack(node.key);
 43                 inOrderTraverseNode(node.right,callBack);
 44             }
 45         }
 46         this.inOrderTraverse = function(callBack){
 47             inOrderTraverseNode(root,callBack);
 48         }
 49         //前序遍历，复制当前的二叉树，效率相对于重新插入二叉树效率要高，前序遍历时间复杂度为O(n),n为节点数，插入二叉树的时间复杂度为n*logn
 50         var preOrderTraverseNode = function(node,callBack){
 51             if(node !== null){
 52                 callBack(node.key);
 53                 preOrderTraverseNode(node.left,callBack);
 54                 preOrderTraverseNode(node.right,callBack);
 55             }
 56         }
 57         this.preOrderTraverse = function(callBack){
 58             preOrderTraverseNode(root,callBack);
 59         }
 60         //后序遍历，主要用于文件夹系统的遍历子文件夹
 61         var postOrderTraverseNode = function(node,callBack){
 62             if(node !== null){
 63                 postOrderTraverseNode(node.left,callBack);
 64                 postOrderTraverseNode(node.right,callBack);
 65                 callBack(node.key);
 66             }
 67         }
 68         this.postOrderTraverse = function(callBack){
 69             postOrderTraverseNode(root,callBack);
 70         }
 71         //查找最小值
 72         var minNode= function(node){
 73             if(node){
 74                 while(node && node.left !== null){
 75                     node = node.left;
 76                 }
 77                 return node.key;
 78             }
 79         }
 80         this.min = function(){
 81             return minNode(root);
 82         }
 83         //查找最大值
 84         var maxNode= function(node){
 85             if(node){
 86                 while(node && node.right !== null){
 87                     node = node.right;
 88                 }
 89                 return node.key;
 90             }
 91         }
 92         this.max = function(){
 93             return maxNode(root);
 94         }
 95         //查找给定的数值
 96         var searchNode = function(node,key){
 97             if(node == null){
 98                 return false;
 99             }
100             if(key < node.key){
101                 return searchNode(node.left,key);
102             }else if(key > node.key){
103                 return searchNode(node.right,key);
104             }else{
105                 return true;
106             }
107         } 
108         this.search = function(key){
109             return searchNode(root,key);
110         }
111         //删除节点
112         var findMinNode = function(node){
113             if(node){
114                 while(node && node.left !== null){
115                     node = node.left;
116                 }
117                 return node;
118             }
119             return null;
120         }
121         var removeNode = function(node,key){
122             if(node == null){
123                 return null;
124             }
125             if(key < node.key){
126                 node.left = removeNode(node.left,key);
127                 return node;
128             }else if(key > node.key){
129                 node.right = removeNode(node.right,key);
130                 return node;
131             }else{
132                 if(node.left == null && node.right == null){
133                     node = null;
134                     return node;
135                 }
136                 if(node.left == null){
137                     node = node.right;
138                     return node;
139                 }else if(node.right == null){
140                     node = node.right;
141                     return node;
142                 }
143                 var aux = findMinNode(node.right);
144                 node.key = aux.key;
145                 node.right = removeNode(node.right,aux.key);
146                 return node;
147             }
148 
149         }
150         this.remove = function(key){
151             root = removeNode(root,key);
152         }
153     }
154     
155     var nodes = [8,3,10,1,6,14,4,7,13];
156     var erchashu = new erchashu();
157     nodes.forEach(function(key){
158         erchashu.inseter(key);
159     })
160     var callBack = function(key){
161         console.log(key);
162     }
163     erchashu.inOrderTraverse(callBack);
164     callBack("这是一条分界线-----------------------------------------");
165     erchashu.preOrderTraverse(callBack);
166     callBack("这是一条分界线-----------------------------------------");
167     erchashu.postOrderTraverse(callBack);
168     callBack("这是一条分界线-----------------------------------------");
169     console.log("这个二叉树的最小值为"+erchashu.min());
170     callBack("这是一条分界线-----------------------------------------");
171     console.log("这个二叉树的最大值为"+erchashu.max());
172     console.log("查找结果"+erchashu.search(9));
173 
174     erchashu.remove(3);
175     erchashu.preOrderTraverse(callBack);
176 </script>
177 </body>
178 </html>

 

posted @ 2018-12-07 10:55  小伙子学编程  阅读(136)  评论(0)    收藏  举报