浅谈排序二叉树

前言：

大学时代，已过去一年多了，数据结构是我们最害怕的课，也是我最喜欢的课，曾经有个plan毕业了研究算法，但是世事难料，最后自己的人生轨迹偏向了游戏行业。

最近不知道那根筋不对，就是想回首，再看看二叉树，以下是我的一些见解，欢迎大家指正！

我们工作中，使用最多的就是排序二叉树（不一定是平衡二叉树哦）

以下代码，包含了，二叉树的创建，前序遍历，中序遍历，后续遍历，查找最大值，查找最小值，查找特定值，删除特定值（子节点，只有右孩子的节点，只有左孩子的节点，拥有左右子树的节点）

var binaryTree = function(){

    var createNode = function(key){
        this.key = key;
        this.left = null;
        this.right = null;
    }


    var insertNode = function(node, newNode){
        if(newNode.key < node.key){
            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);
            }
        }
    }


    var root = null;
    this.createTree = function(key){
        var newNode = new createNode(key);
        if(root === null){
            root = newNode;
        }else{
            insertNode(root, newNode);
        }
    }




    // 中序遍历: 输出升序的数组
    var inorderTraversalNode = function(node){
        if(node !== null){
            inorderTraversalNode(node.left);
            console.log(node.key);
            inorderTraversalNode(node.right);
        }
    }


    // 前序遍历：高效复制一个二叉树（On）
    var preTraversalNode = function(node){
        if(node !== null){
            console.log(node.key);
            preTraversalNode(node.left);
            preTraversalNode(node.right);
        }
    }


    // 后序遍历：文件系统的遍历
    var postTraversalNode = function(node){
        if(node !== null){
            preTraversalNode(node.left);
            preTraversalNode(node.right);
            console.log(node.key);
        }
    }


    // type 1:前序
    // type 2:中序
    // type 3:后序
    this.traversal = function(type){
        switch(type){    
            case 1:
                preTraversalNode(root);
                break;
            case 2:
                inorderTraversalNode(root);
                break;
            case 3:
                postTraversalNode(root)
                break;
        }
    }


    var minNode = function(node){
        if(node){
            if(node.left){
                return minNode(node.left);
            }else{
                return node.key;
            }
        }
        return null;
    }
    this.min = function(){
        return minNode(root);
    }



    var maxNode = function(node){
        if(node){
            if(node.right){
                return maxNode(node.right)
            }else{
                return node.key;
            }
            return null;
        }
    }
    this.max = function(){
        return maxNode(root);
    }    


    var searchNode = function(node, key){
        if(node){
            if(key < node.key){
                return searchNode(node.left, key);
            }else if(key > node.key){
                return searchNode(node.right, key);
            }else{
                return true;
            }
        }
        return false;
    }
    this.search = function(key){
        return searchNode(root, key);
    }    

    var findMinNode = function(node){
        if(node){
            if(node.left){
                return findMinNode(node.left);
            }else{
                return node;
            }
        }
        return null;
    }
    var removeNode = function(node, key){
        if(node){
            if(key < node.key){
                node.left = removeNode(node.left, key);
                return node;
            }else if(key > node.key){
                node.right = removeNode(node.right, key);
                return node;
            }else{
                if(node.left === null && node.right === null){
                    node = null;
                    return node;
                }else if(node.left === null){
                    node = node.right;
                    return node;
                }else if(node.right === null){
                    node = node.left;
                    return node;
                }else{
                    var aux = findMinNode(node.right);
                    node.key = aux.key;
                    node.right = removeNode(node.right, aux.key);
                    return node;
                }
            }
        }
    }
    this.remove = function(key){
        root = removeNode(root, key)
    }
}


var tree = new binaryTree();
var arr = [4, 2, 12, 10, -7, 21, 3, 99, 76];
for(var i = 0; i < arr.length; i ++){
    tree.createTree(arr[i]);
}

tree.traversal(2);
console.log('The tree minNode key is ' + tree.min());
console.log('The tree maxNode key is ' + tree.max());
console.log(tree.search(12) ? 'The key is 12 is found' : 'The key is 12 is not found');
console.log(tree.search(11) ? 'The key is 11 is found' : 'The key is 11 is not found');