java算法02 - 树

树是一类重要的非线性结构。而二叉树是一种比较重要的树，接下来我们来了解二叉树的相关内容。

二叉搜索树：每个节点都不比它左子树的任意元素小，而且不比它的右子树的任意元素大。

/**
 * 二叉搜索树 O(n)
 *
 * @author jade
 *
 */
public class BinarySearchTree {

    private int count;
    private Node root;

    public int size() {
        return count;
    }

    public boolean isEmpty() {
        return count == 0;
    }

    /**
     * 插入元素
     *
     * @param key
     * @param value
     */
    public void insert(int key, Object value) {
        root = insert(root, key, value);
    }

    private Node insert(Node node, int key, Object value) {
        if (node == null) {
            count++;
            return new Node(key, value);
        }
        if (key == node.key) {
            node.value = value;
        } else if (key < node.key) {
            node.left = insert(node.left, key, value);
        } else {
            node.right = insert(node.right, key, value);
        }
        return node;
    }

    public boolean contain(int key) {
        return contain(root, key);
    }

    private boolean contain(Node node, int key) {
        if (node == null) {
            return false;
        }
        if (key == node.key) {
            return true;
        } else if (key < node.key) {
            return contain(node.left, key);
        } else {
            return contain(node.right, key);
        }
    }

    public Node search(int key) {
        return search(root, key);
    }

    private Node search(Node node, int key) {
        if (node == null) {
            return null;
        }
        if (key == node.key) {
            return node;
        } else if (key < node.key) {
            return search(node.left, key);
        } else {
            return search(node.right, key);
        }
    }

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

    private void preOrder(Node node) {
        if (node != null) {
            System.out.println(node.key);
            preOrder(node.left);
            preOrder(node.left);
        }
    }

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

    private void inOrder(Node node) {
        if (node != null) {
            inOrder(node.left);
            System.out.println(node.key);
            inOrder(node.right);
        }
    }

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

    private void postOrder(Node node) {
        if (node != null) {
            postOrder(node.left);
            postOrder(node.right);
            System.out.println(node.key);
        }
    }

    /**
     * 层序遍历（广度优先遍历）
     */
    public void levelOrder() {
        ConcurrentLinkedQueue<Node> queue = new ConcurrentLinkedQueue<Node>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node node = queue.peek();
            System.out.println(node.key);
            if (node.left != null) {
                queue.add(node.left);
            }
            if (node.right != null) {
                queue.add(node.right);
            }
        }
    }

    /**
     * key最小值的节点
     *
     * @return
     */
    public Node getMin() {
        if (root == null) {
            return null;
        }
        return minNode(root);
    }

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

    /**
     * key最大值的节点
     *
     * @return
     */
    public Node getMax() {
        if (root == null) {
            return null;
        }
        return getMax(root);
    }

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

    /**
     * 删除最小值节点
     */
    public void removeMin() {
        if (root != null) {
            root = removeMin(root);
        }
    }

    private Node removeMin(Node node) {
        if (node.left == null) {
            Node rightNode = node.right;
            count--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }

    /**
     * 删除最大值所在节点
     */
    public void removeMax() {
        if (root != null) {
            root = removeMax(root);
        }
    }

    private Node removeMax(Node node) {
        if (node.right == null) {
            Node leftNode = node.left;
            count--;
            return leftNode;
        }
        node.right = removeMax(node.right);
        return node;
    }    

    class Node {
        int key;
        Object value;
        Node left;
        Node right;

        public Node(int key, Object value) {
            this.key = key;
            this.value = value;
        }
    }
}