数据结构 -- 二分搜索树

二分搜索树

1.若它的左子树不为空，则左子树上所有结点的值均小于等于根结点的值；

2.若它的右子树不为空，则右子树上所有结点的值均大于等于根结点的值；

3.它的左右子树均为二分查找树。

图片（注：百度搜索而来的图片）链接: link.

功能

1.获得树中的元素个数

2.树是否为空

3.添加元素

4.是否包含元素e

5.树遍历

前序遍历
中序遍历
后序遍历
层序遍历

6.树的最大深度

7.删除元素

删除最小元素
删除最大元素
删除任意元素

8.树中最小元素

9.树中最大元素

java代码实现

// An highlighted block
public class BSTree {
    /**
     * 节点类
     */
    private class Node {
        public Node left;
        public Node right;
        public int E;

        public Node(int e) {
            left = null;
            right = null;
            this.E = e;
        }
    }
    private Node root;
    private int size;

    private int depth;

    public BSTree() {
        root = null;
        this.size = 0;
    }
    /**
     * 返回二分搜索树中元素的个数
     *
     * @return
     */
    public int getSize() {
        return this.size;
    }

    /**
     * 返回二分搜索树中元素是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return this.size <= 0;
    }

    /**
     * 添加元素
     *
     * @param e
     */
    public void add(int e) {
        root = _add(root, e);
    }

    private Node _add(Node node, int e) {
        if (node == null) {
            this.size++;
            return new Node(e);
        }
        if (node.E > e) {
            node.left = _add(node.left, e);
        } else if (node.E < e) {
            node.right = _add(node.right, e);
        }
        return node;
    }

    /**
     * 是否包含元素e
     *
     * @param e
     * @return
     */
    public boolean contains(int e) {
        return _contains(root, e);
    }

    private boolean _contains(Node node, int e) {
        if (node == null) return false;
        if (node.E == e) return true;
        else if (node.E > e) return _contains(node.left, e);
        else return _contains(node.right, e);
    }

    /**
     * 前序遍历
     */
    public void preOrder() {
        _preOrder(root);
    }

    private void _preOrder(Node node) {
        if (node == null) return;
        System.out.println(node.E);
        _preOrder(node.left);
        _preOrder(node.right);
    }

    /**
     * 后序遍历
     */
    public void postOrder() {
        _postOrder(root);
    }

    private void _postOrder(Node node) {
        if (node == null) return;
        _postOrder(node.left);
        _postOrder(node.right);
        System.out.println(node.E);
    }

    /**
     * 中序遍历
     */
    public void inOrder() {
        _inOrder(root);
    }

    private void _inOrder(Node node) {
        if (node == null) return;
        _inOrder(node.left);
        System.out.println(node.E);
        _inOrder(node.right);
    }

    /**
     * 层序遍历
     */
    public void levelOrder() {
        _levelOrder();
    }

    private void _levelOrder() {
        if (root == null) {
            return;
        }
        Queue<Node> queue = new LinkedList<Node>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node n = queue.remove();
            System.out.println(n.E);
            if (n.left != null)
                queue.add(n.left);
            if (n.right != null)
                queue.add(n.right);
        }
    }

    /**
     * 二分搜索树转为字符串
     *
     * @return
     */
    public String toString() {
        StringBuffer result = new StringBuffer();
        _generateString(root, result, 0);
        return result.toString();
    }

    /**
     * 二分搜索树的最大深度
     * @return
     */
    public int depth() {
        this.depth = 0;
        _fall(root, 1);
        return this.depth;
    }
    private void _fall(Node node, int depth) {

        if (depth > this.depth && (node.left == null && node.right == null)) {
            this.depth = depth;
        }
        if (node.right != null) {
            _fall(node.right, depth + 1);
        }

        if (node.left != null) {
            _fall(node.left, depth + 1);
        }
    }

    private void _generateString(Node node, StringBuffer result, int depth) {
        if (node == null) {
            result.append(_generateDepthString(depth) + "\n");
            return;
        }
        result.append(_generateDepthString(depth) + node.E + "\n");
        _generateString(node.left, result, depth + 1);
        _generateString(node.right, result, depth + 1);
    }

    private String _generateDepthString(int depth) {
        StringBuffer depthString = new StringBuffer();
        for (int i = 0; i < depth; i++) {
            depthString.append("-");
        }
        return depthString.toString();
    }
    /**
     * 删除元素e
     *
     * @param e
     */
    public void remove(int e) {
        root = _remove(root, e);
    }

    private Node _remove(Node node, int e) {
        if (node == null) return null;
        if (node.E > e) {
            node.left = _remove(node.left, e);
            return node;
        } else if (node.E < e) {
            node.right = _remove(node.right, e);
            return node;
        } else {
            // 待删除节点左子树为空的情况
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                this.size--;
                return rightNode;
            }
            // 待删除节点右子树为空的情况
            if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                this.size--;
                return leftNode;
            }

            Node min_right = _minNode(node.right);
            min_right.right = _removeMin(node.right);
            min_right.left = node.left;
            node.left = null;
            node.right = null;
            return min_right;
        }

    }

    /**
     * 最小元素
     *
     * @return
     */
    public int min() {
        return _minNode(root).E;
    }

    private Node _minNode(Node node) {
        if (node.left == null) return node;
        return _minNode(node.left);
    }

    /**
     * 最大元素
     *
     * @return
     */
    public int max() {
        return _maxNode(root).E;
    }

    private Node _maxNode(Node node) {
        if (node.right == null) return node;
        return _minNode(node.right);
    }

    /**
     * 删除最小的元素
     *
     * @return
     */
    public int removeMin() {
        int min = min();
        root = _removeMin(root);
        return min;
    }

    private Node _removeMin(Node node) {
        if (node == null) return null;
        if (node.left == null) {
            Node rightNode = node.right;
            this.size--;
            node.right = null;
            return rightNode;
        }
        node.left = _removeMin(node.left);
        return node;
    }