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);
        }
    }
}