javaScript数据结构 07 二叉搜索树

javaScript数据结构之树

01 树

树是一种分层数据模型。

我曾经写过一个json解析成图像来操作的插件，用的就是树的结构。

02 术语

• 树的存储单元叫做 节点
• 树的顶部节点叫做 根节点
• 不是根节点，且有子节点的叫做 内部节点
• 没有子节点的叫做 叶子节点
• 节点距离根节点的数目叫做 节点深度

03 二叉树

所谓二叉树—最多只能有两个子节点。 即左节点和右节点
二叉树应用最为广泛。

04 二叉搜索树

我们规定，二叉树左侧只能存放比本节点小的值，右侧存放不小于本节点的值。 这样子的树，便于搜索，我们称为二叉搜索树。

05 实现二叉搜索树

先构建两个基础类，二叉搜索树类和节点类（私有类）

;(function(root) {
// 节点类
function Node(key) {
    this.key = key;
    this.left = null;
    this.right = null;
};
// 树
function Tree() {
    var _root = null;
}
// 注册公开类
root.Tree = Tree;
})(this);

实现添加方法

this.insert = function(key) {
    var newNode = new Node(key);
    if (_root === null) {
        _root = newNode;
    } else {
        // 递归添加
        insertNode(_root, newNode);
    }
};
function insertNode(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.forEach = function(fn) {
    forEach(_root, fn);
};
function forEach(node, fn) {
    if (node != null) {
        fn(node.key);
        forEach(node.left, fn);
        forEach(node.right, fn);
    }
}

再实一个求最小值方法

this.min = function() {
    return minNode(_root).key;
};

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

最后实现移除方法

this.remove = function(key) {
    return remove(_root, key);
};
function remove(node, key) {
    if (node === null) {
        return null;
    };

    if (key < node.key) {
        node.left = remove(node.left, key);
        return node;
    } else if (key >　node.key) {
        node.right = remove(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 currNode = minNode(node.right);
        node.key = currNode.key;
        node.right = remove(node.right, currNode.key);
        return node;
    }
};

大功告成

;(function(root) {

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

function Tree() {
    var _root = null;
    this.insert = function(key) {
        var newNode = new Node(key);
        if (_root === null) {
            _root = newNode;
        } else {
            insertNode(_root, newNode);
        }
    };

    this.forEach = function(fn) {
        forEach(_root, fn);
    };

    this.min = function() {
        return minNode(_root).key;
    };

    this.max = function() {
        return maxNode(_root).key;
    };

    this.remove = function(key) {
        return remove(_root, key);
    };

    function remove(node, key) {
        if (node === null) {
            return null;
        };

        if (key < node.key) {
            node.left = remove(node.left, key);
            return node;
        } else if (key >　node.key) {
            node.right = remove(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 currNode = minNode(node.right);
            node.key = currNode.key;
            node.right = remove(node.right, currNode.key);
            return node;
        }
    };

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

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

    function forEach(node, fn) {
        if (node != null) {
            fn(node.key);
            forEach(node.left, fn);
            forEach(node.right, fn);
        }
    }

    function insertNode(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);
            }
        }
    }
};

root.Tree = Tree;

})(this);

我们测试一下：

var tree = new Tree();
tree.insert(2);
tree.insert(10);
tree.insert(6);
tree.insert(7);
tree.insert(8);
tree.insert(1);
tree.insert(55);
tree.insert(9);
tree.forEach(function (n){
    console.log(n);
});
console.log(tree.min());
tree.remove(55);
console.log(tree.max());