数据结构之二叉查找树

package tree;

public class BinarySearchTree<T extends Comparable<? super T>>{
    private BinaryNode<T> root;
    private static class BinaryNode<T>{
        T element; //data
        BinaryNode<T>left; //left child
        BinaryNode<T>right; //right child
        public BinaryNode(T element) {
            constructor stub
            this(element, null, null);
        }

        public BinaryNode(T theElement,BinaryNode<T> theLeft,BinaryNode<T>theRight) {
            constructor stub
            left=theLeft;
            element=theElement;
            right=theRight;
        }

    }

    public BinarySearchTree(){
        root=null;
    }

    public void makeEmpty(){
        root=null;
    }

    public boolean isEmpty(){
        return root==null;
    }

    public boolean contains(T value){
        return contains(value,root);
    }

    public T findMin(){
        return findMin(root).element;
    }

    public T findMax(){
        return findMax(root).element;
    }

    public void insert(T value){
        root=insert(value, root);
    }

    public void remove(T value){
        root=remove(value, root);
    }

    //反转二叉树
    public void invertBinaryTree(BinaryNode<T> node){
        if (node==null) {
            return;
        }
        BinaryNode<T> temp=node.left;
        node.left=node.right;
        node.right=temp;

        invertBinaryTree(node.left);
        invertBinaryTree(node.right);
    }

    public void printTree(){
        if (isEmpty()) {
            System.out.println("Empty Tree");
        }
        else {
            printTree(root);
        }
    }

    //中序遍历
    private void printTree(BinaryNode<T> node){
        if (node!=null) {
            printTree(node.left);
            System.out.println(node.element);
            printTree(node.right);
        }
    }

    private int height(BinaryNode<T> node){
        if (node==null) {
            return -1;
        }
        else {
            return 1+Math.max(height(node.left), height(node.right));
        }
    }

    private boolean contains(T value,BinaryNode<T> node){
        if (node==null) {
            return false;
        }
        int compareResult=value.compareTo(node.element);
        if (compareResult<0) {
            return contains(value, node.left);
        }
        else if (compareResult>0) {
            return contains(value, node.right);
        }
        else {
            return true;
        }
    }

    private BinaryNode<T> findMin(BinaryNode<T> node){
        if (node==null) {
            return null;
        }
        else if (node.left==null) {
            return node;
        }
        return findMin(node.left);
    }

    private BinaryNode<T> findMax(BinaryNode<T> node){
        if (node==null) {
            return null;
        }
        else if (node.right==null) {
            return node;
        }
        return findMax(node.right);
    }
    private BinaryNode<T> insert(T value,BinaryNode<T> node){
        if (node==null) {
            return new BinaryNode<T>(value, null, null);
        }
        int compareResult=value.compareTo(node.element);
        if (compareResult<0) {
            node.left=insert(value, node.left);
        }
        else if (compareResult>0) {
            node.right=insert(value, node.right);
        }
        else {

        }
        return node;
    }

    private BinaryNode<T> remove(T value,BinaryNode<T>node){
        if (node==null) {
            return node;
        }
        int compareResult=value.compareTo(node.element);
        if (compareResult<0) {
            node.left=remove(value, node.left);
        }
        else if (compareResult>0) {
            node.right=remove(value, node.right);
        }
        else if (node.left!=null && node.right!=null) { //有两个孩子
            node.element=findMin(node.right).element;
            node.right=remove(node.element, node.right);
        }
        else {
            node=(node!=null)?node.left:node.right;
        }
        return node;
    }

}