java 二叉查找树（搜索树、排序树）实现

二叉查找树，又称二叉搜索树，又称二叉排序树，可以是null树。主要思想如下，如树的左子树非空，则左子树的所有节点值都小于根节点值，若树的右子树非空，则右子树的所有节点值都大于根节点值。下面就基于这个思路来实现代码了，代码只实现了几个简单方法，也参考了网上一些实现代码。

class BinarySearchTree<E extends Comparable<E>> {

    Node<E> root;
    int size;

    static class Node<E> {
        Node<E> parent;
        Node<E> left;
        Node<E> right;
        E value;
        public Node(E e, Node<E> parent, Node<E> left, Node<E> right) {
            this.value = e;
            this.parent = parent;
            this.left = left;
            this.right = right;
        }
    }

    boolean insert(E e) {
        Node<E> node = new Node<E>(e, null, null, null);
        if (root == null) {
            root = node;
            size++;
            return true;
        } else {
            Node<E> pointer = root;
            while (true) {
                // insert left
                if (pointer.value.compareTo(e) > 0) {
                    if (pointer.left == null) {
                        node.parent = pointer;
                        pointer.left = node;
                        size++;
                        return true;
                    } else {
                        pointer = pointer.left;
                    }
                }  
                // insert right
                else if (pointer.value.compareTo(e) < 0) {
                    if (pointer.right == null) {
                        node.parent = pointer;
                        pointer.right = node;
                        size++;
                        return true;
                    } else {
                        pointer = pointer.right;
                    }
                } 
                // equal return false
                else {
                    return false;
                }
            }
        }
    }

    Node<E> get(E e) {
        if (e == null) {
            throw new NullPointerException("e == null");
        }
        Node<E> cur = root;
        while (cur != null) {
            if (cur.value.compareTo(e) > 0) {
                cur = cur.left;
            }
            else if (cur.value.compareTo(e) < 0) {
                cur = cur.right;
            }
            else {
                break;
            }
        }
        return cur;
    }

    E getMin(Node<E> node) {
        Node<E> min = getMinNode(node);
        return min == null ? null : min.value;
    }

    Node<E> getMinNode(Node<E> node) {
        Node<E> min = node;
        while (min != null && min.left != null) {
            min = min.left;
        }
        return min;
    }

    E getMax(Node<E> node) {
        Node<E> max = getMaxNode(node);
        return max == null ? null : max.value;
    }

    Node<E> getMaxNode(Node<E> node) {
        Node<E> max = node;
        while (max != null && max.right != null) {
            max = max.right;
        }
        return max;
    }

    // 中序遍历递归实现
    void LDR(Node<E> node) {
        if (node != null) {
            LDR(node.left);
            System.out.println(node.value.toString());
            LDR(node.right);
        }
    }
}