JavaScript实现二叉搜索树

最新推荐文章于 2023-04-19 12:31:14 发布

SignalFire

最新推荐文章于 2023-04-19 12:31:14 发布

阅读量184

点赞数

分类专栏： JavaScript数据结构与算法文章标签： javascript 二叉搜索树

本文链接：https://blog.csdn.net/signalfire/article/details/125393138

版权

JavaScript数据结构与算法专栏收录该内容

12 篇文章 0 订阅

订阅专栏

JavaScript实现二叉搜索树

前序、中序、后序遍历均为左节点在右节点之前

区别：

前序遍历根节点在前，顺序是根->左->右

中序遍历根节点在中，顺序是左->根->右

后序遍历根节点在后，顺序是左->右->根

<!DOCTYPE html>
<html>
   <head>
       <meta charset="utf-8">
       <title></title>
   </head>
   <body>
   </body>
   <script>
       class Node{
           constructor(val){
               this.val = val;
               this.left = null;
               this.right = null;
           }
       }

       class BinarySearchTree{
           constructor(){
               this.root = null;
           }

           insert(val){
               if(this.root == null){
                   this.root = new Node(val);
               }else{
                   this.insertNode(this.root,val);
               }
           }

           insertNode(node,val){
               if(node.val > val){
                   if(node.left == null){
                       node.left = new Node(val);
                   }else{
                       this.insertNode(node.left,val);
                   }
               }else{
                   if(node.right == null){
                       node.right = new Node(val);
                   }else{
                       this.insertNode(node.right,val);
                   }
               }
           }

           // 先序遍历
           preOrderTraverse(){
               this.preOrderTraverseNode(this.root);
           }

           preOrderTraverseNode(node){
               console.log(node.val);
               if(node.left) this.inOrderTraverseNode(node.left);
               if(node.right) this.inOrderTraverseNode(node.right);
           }

           // 中序遍历
           inOrderTraverse(){
               this.inOrderTraverseNode(this.root);
           }

           inOrderTraverseNode(node){
               if(node.left) this.preOrderTraverseNode(node.left);
               console.log(node.val);
               if(node.right) this.preOrderTraverseNode(node.right);
           }

           // 后序遍历
           postOrderTraverse(){
               this.postOrderTraverseNode(this.root);
           }

           postOrderTraverseNode(node){
               if(node.left) this.postOrderTraverseNode(node.left);
               if(node.right) this.postOrderTraverseNode(node.right);
               console.log(node.val);
           }

           // 层序遍历
           levelOrder(root) {
           if(root == null) return [];

           let result = [];
           let nodeArr = [];

           nodeArr.push(root);

           while(nodeArr.length){
           let size = nodeArr.length;
           let arr = [];
           for(let i = 0; i < size; i++){
           let node = nodeArr.shift();
           arr.push(node.val);
           if(node.left != null) nodeArr.push(node.left);
           if(node.right != null) nodeArr.push(node.right);
           }
           result.push(arr);
           }
           return result;
           }
       }

       let bTree = new BinarySearchTree();

       bTree.insert(11);
       bTree.insert(7);
       bTree.insert(15);
       bTree.insert(5);
       bTree.insert(9);
       bTree.insert(13);
       bTree.insert(20);

       console.log("pre")
       bTree.preOrderTraverse();
       console.log("in");
       bTree.inOrderTraverse();
       console.log("post");
       bTree.postOrderTraverse();
       console.log("level");
       let arr = bTree.levelOrder(bTree.root);
       console.log(arr);
   </script>
</html>

SignalFire

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaScript实现二叉搜索树

JavaScript实现二叉搜索树前序、中序、后序遍历均为左节点在右节点之前区别：前序遍历根节点在前，顺序是根->左->右中序遍历根节点在中，顺序是左->根->右后序遍历根节点在后，顺序是左->右->根...
复制链接

扫一扫