js二叉树的建立与中序遍历

二叉树概念

1.除了最下面一层，每个节点都是父节点，每个节点都有且最多有两个子节点；

2.除了最上面一层，每个节点是子节点，每个节点都会有一个父节点；

3.最上面一层的节点为根节点；

图例说明：

中序遍历概念

先打印左子树（左子节点），接着打印父节点，最后打印右子树（右子节点）

 

 代码实现：

 //创建二叉树
        function Node(data,left,right){
            this.data = data;
            this.left = left;
            this.right = right;
        }
        Node.prototype.show = function(){
            return this.data;
        }
        function BST(){
            this.root = null;
        }
        BST.prototype.insert = function(data){
            var node = new Node(data,null,null);
            if(this.root == null){
                this.root = node;
            }else{
                var current = this.root;
                var parent;
                while(true){
                    parent = current;
                    if(data < current.data){
                        current = current.left;
                        if(current == null){
                            parent.left = node;
                            break;
                        }
                    }else{
                        current = current.right;
                        if(current == null){
                            parent.right = node;
                            break;
                        }
                    }
                }
            }
        }
        //二叉树中序遍历
        BST.prototype.inOrder = function(node){
            if(node){
                this.inOrder(node.left);
                console.log(node.show() + " ");
                this.inOrder(node.right);
            }
        }
        //测试数据
        var bst  = new BST();
        var nums = [10,3,18,2,4,13,21,9,8,9];
        for(var i = 0;i < nums.length;i ++){
            bst.insert(nums[i]);
        }
        console.log(bst.root)
        bst.inOrder(bst.root);

//定义节点
    class Node {
        constructor(data) {
            this.root = this;
            this.data = data;
            this.left = null;
            this.right = null;
        }
    }
    //创建二叉搜索树(BST)）
    class BinarySearchTree {
        constructor() {
            this.root = null;
        }
        //插入节点
        insert(data) {
            const newNode = new Node(data);
            const insertNode = (node, newNode) => {
                if (newNode.data < node.data) {
                    if (node.left === null) {
                        node.left = newNode;
                    } else {
                        insertNode(node.left, newNode);
                    }
                } else {
                    if (node.right === null) {
                        node.right = newNode;
                    } else {
                        insertNode(node.right, newNode);
                    }

                }
            };
            if (!this.root) {
                this.root = newNode;
            } else {
                insertNode(this.root, newNode);

            }
        }
        //中序遍历
        inOrder() {
            let backs = [];
            const inOrderNode = (node, callback) => {
                if (node !== null) {
                    inOrderNode(node.left, callback);
                    backs.push(callback(node.data));
                    inOrderNode(node.right, callback);
                }
            };
            inOrderNode(this.root, callback);

            function callback(v) {
                return v;
            }
            return backs;
        }
        //前序遍历
        preOrder() {
            let backs = [];
            const preOrderNode = (node, callback) => {
                if (node !== null) {
                    backs.push(callback(node.data));
                    preOrderNode(node.left, callback);
                    preOrderNode(node.right, callback);
                }
            };
            preOrderNode(this.root, callback);

            function callback(v) {
                return v;
            }
            return backs;
        }
        //后序遍历
        postOrder() {
            let backs = [];
            const postOrderNode = (node, callback) => {
                if (node !== null) {
                    postOrderNode(node.left, callback);
                    postOrderNode(node.right, callback);
                    backs.push(callback(node.data));
                }
            };
            postOrderNode(this.root, callback);

            function callback(v) {
                return v;
            }
            return backs;
        }
        //查找最小值
        getMin(node) {
            const minNode = node => {
                return node ? (node.left ? minNode(node.left) : node) : null;
            };
            return minNode(node || this.root);
        }
        //查找最大值
        getMax(node) {
            const minNode = node => {
                return node ? (node.right ? minNode(node.right) : node) : null
            };
            return minNode(node || this.root);
        }
        //查找特定值
        find(data) {
            const findNode = (node, data) => {
                if (node === null) return false;
                if (node.data === data) return node;
                return findNode((data < node.data) ? node.left : node.right, data);
            };
            return findNode(this.root, data);

        }
        //删除节点
        remove(data) {
            const removeNode = (node, data) => {
                if (node === null) return null;
                if (node.data === data) {
                    if (node.left === null && node.right === null) return null;
                    if (node.left === null) return node.right;
                    if (node.right === null) return node.left;
                    if (node.left !== null && node.right !== null) {
                        let _node = this.getMin(node.right);
                        node.data = _node.data;
                        node.right = removeNode(node.right, data);
                        return node;
                    }
                } else if (data < node.data) {
                    node.left = removeNode(node.left, data);
                    return node;
                } else {
                    node.right = removeNode(node.right, data);
                    return node;
                }
            };
            return removeNode(this.root, data);
        }
    }
    //创建BST
    const tree = new BinarySearchTree();
    tree.insert(11);
    tree.insert(7);
    tree.insert(5);
    tree.insert(3);
    tree.insert(9);
    tree.insert(8);
    tree.insert(10);
    tree.insert(13);
    tree.insert(12);
    tree.insert(14);
    tree.insert(20);
    tree.insert(18);
    tree.insert(25);
    console.log(tree);
    console.log(tree.root);
    //中序遍历BST
    console.log(tree.inOrder());
    //前序遍历BST
    console.log(tree.preOrder());
    //后序遍历BST
    console.log(tree.postOrder());
    //搜索最小值
    console.log(tree.getMin());
    //搜索最大值
    console.log(tree.getMax());
    //查找特定值
    console.log(tree.find(2));
    console.log(tree.find(3));
    console.log(tree.find(20));
    //删除节点，返回新的二叉树，不改变原来的二叉树
    console.log(tree.remove(11));
    a = tree.remove(11);
    console.log(a.root);
    console.log(tree);

 

原文