数据结构二叉树的遍历、查找、删除

数据结构树，二叉树，后续有理解到的或有用到在新增，其他很多高级树多是基于二叉树，
主要来自慕课

此处知乎上的一些说法，可进一步根据这些深入学习，现在还未学习数据库和后台，先了解下，
主要用途多是查找、删除、插入等的操作

二叉树
定义：

应用

code

function BinaryTree (){
    // "use strict";
    var Node = function (key) {
        this.key = key;
        this.left = null;
        this.right = null;
    };

    var root = 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);
            }
        }
    }
    this.insert = function (key) {
        var newNode = new Node(key);
        if(root === null){
            root = newNode;
        }else {
            insertNode( root, newNode);
        }
    };

    var inOrderTraverseNode = function (node, callback) {
        if(node !== null){
            inOrderTraverseNode(node.left, callback);
            callback(node.key);
            inOrderTraverseNode(node.right, callback);
        }
    };
    //中序遍历api接口，输出从小到大
    this.inOrderTraverse = function (callback) {
        inOrderTraverseNode(root, callback);
    };

    var preOrderTraverseNode = function (node,callback) {
        if(node !== null){
            callback(node.key);
            preOrderTraverseNode(node.left, callback);
            preOrderTraverseNode(node.right, callback);
        }
    };
    //前序遍历，
    this.preOrderTraverse = function (callback) {
        preOrderTraverseNode(root, callback);
    };

    var postOrderTraverseNode = function (node, callback) {
        if (node !== null){
            postOrderTraverseNode(node.left, callback);
            postOrderTraverseNode(node.right, callback);
            callback(node.key);
        }
    }
    //后序遍历，
    this.postOrderTraverse = function (callback) {
        postOrderTraverseNode(root, callback);
    }

    var minNode = function (node) {
        if (node){
            while(node && node.left !== null){
                node = node.left;
            }
            return node.key;
        }
        return null;
    }

    //查找最小值
    this.min = function () {
        return minNode(root);
    }

    var maxNode = function (node) {
        if(node){
            while(node && node.right !== null){
                node = node.right;
            }
            return node.key;
        }
        return null;
    }

    //查找最大值
    this.max = function () {
        return maxNode(root);
    }

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

    //查找任意值
    this.search = function (key) {
        return searchNode(root, key);
    }

    var finMinNode = function (node) {
        if (node){
            while (node && node.left !== null){
                node = node.left;
            }
            return node;
        }
    };

    var removeNode = function (node, key) {
        if(node === null){
            return null;
        }
        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;
            }
            //删除中间节点（只有下边一侧的节点）
            if (node.left === null){
                node = node.right;
                return node;
            }else if (node.right === null){
                node = node.left;
                return node;
            }

            //删除中间节点（还有下边两侧节点）
            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 nodes = [8,3,10,1,6,14,4,7,13];
var binaryTree = new BinaryTree();
nodes.forEach(function (key) {
    binaryTree.insert(key);
});

var callback = function (key) {
    console.log(key);
}

binaryTree.inOrderTraverse(callback);
binaryTree.preOrderTraverse(callback);
binaryTree.postOrderTraverse(callback);

// alert('binaryTrees min value is' + binaryTree.min());
// alert('binaryTrees max value is' + binaryTree.max());
// alert(binaryTree.search(10) ? 'search 10 in binaryTree success!' : 'search 10 in binaryTree fail!');
// alert(binaryTree.search(9) ? 'search 9 in binaryTree success!' : 'search 9 in binaryTree fail!');
binaryTree.remove(1);
binaryTree.remove(10);
binaryTree.remove(3);
binaryTree.inOrderTraverse(callback);
console.log(binaryTree);