JavaScript实现二叉搜索树

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>