二叉查找树的基本操作与实现（二叉链表实现）

package eureka.server.tree;

public class BinarySearchTree<T extends Comparable> implements Tree<T>{

   //根节点
    protected BinaryNode<T> root;

    public BinaryNode<T> getRoot() {
        return root;
    }

    public void setRoot(BinaryNode<T> root) {
        this.root = root;
    }

    @Override
    public String toString() {
        return "BinarySearchTree{" +
                "root=" + root +
                '}';
    }

    @Override
    public void insert(T data) {
      if(data ==null){
          throw new IllegalArgumentException();
      }
        root = insertNode(data,root);
    }


    /**
     * 插入节点
     * @param data
     * @param p
     * @return
     */
    private BinaryNode<T> insertNode(T data, BinaryNode<T> p){
        //如果根节点为空，创建一个根节点
        if(p==null)
            return new BinaryNode<T>(data);
        //比较插入节点和当前节点的值
        int result = data.compareTo(p.getData());
        if(result < 0){
            p.setLeftNode(insertNode(data,p.getLeftNode()));
        }else if(result > 0){
            p.setRightNode(insertNode(data, p.getRightNode()));
        }else{
        }
        return p;
    }


    /**
     * 查找最小值节点
     * @param binaryNode
     * @return
     */
    private  BinaryNode<T> findMin(BinaryNode binaryNode){
         if(binaryNode.getLeftNode() == null){
             return binaryNode;
         }
         return findMin(binaryNode.getLeftNode());
    }

    /**
     * 查找最小值节点
     * @param binaryNode
     * @return
     */
    private  BinaryNode<T> findMax(BinaryNode binaryNode){
        if(binaryNode.getRightNode() == null){
            return binaryNode;
        }
        return findMax(binaryNode.getRightNode());
    }


    /**
     * 删除节点
     * @param data
     * @param p
     * @return
     */
    private BinaryNode<T> remove(T data, BinaryNode<T> p){
        //没有找到要递归的元素，返回bull
        if(p == null){
            return null;
        }
        //查找要删的值
        int result = data.compareTo(p.getData());
        //小于0，从左边开始查找
        if(result < 0){
           p.setLeftNode(remove(data, p.getLeftNode()));
           //大于0，从右边开始查找
        }else if(result > 0){
            p.setRightNode(remove(data, p.getRightNode()));
            //要删除的节点拥有2个子节点
        }else if(p.getRightNode() != null && p.getRightNode() != null){
               //找到替换的节点，并将值赋值给要删除的节点
               p.setData(findMin(p.getRightNode()).getData());
               //将替换的值删除掉
               p.setRightNode(remove(p.getData(), p.getRightNode()));
               //只有一个子节点或者是叶子节点的情况
        }else {
            p = p.getLeftNode() != null? p.getLeftNode():p.getRightNode();
        }
        return p;
    }


    /**
     * 求树的深度
     * @return
     */
    public int hight(){
      return hight(root);
    }

    /**
     * 递归求树的深度
     * @param node
     * @return
     */
    public int hight(BinaryNode<T> node){
        if(node == null){
            return 0;
        }else {
            int left = hight(node.getLeftNode());
            int right = hight(node.getRightNode());
            return left > right? left + 1: right+1 ;
        }
    }

    /**
     * 求二叉平衡树的size
     *
     * @return
     */
    public int size(){
      return size(root);
    }

    /**
     * 求二叉平衡树的size
     * 递归，每一层的大小等于节点的左子树的大小加上右子树的大小加1
     *
     * @return
     */
    public int size(BinaryNode<T> p){
      if(p == null){
          return 0;
      }else {
          return size(p.getLeftNode()) + 1 + size(p.getRightNode());
      }
    }


    /**
     * 先根遍历，先遍历根节点，再遍历左节点，右节点
     * @return
     */
    public String preOrder(){
       String s= preOrder(root).toString();
       if(s.length() > 0){
           s = s.substring(0,s.length() - 1);
       }
       return s;
    }

    /**
     * 先根遍历
     * @param p
     * @return
     */
    public String preOrder(BinaryNode<T> p){
        StringBuffer sb = new StringBuffer();
       if(p != null){
           sb.append(p.getData() + ",");
           sb.append(preOrder(p.getLeftNode()));
           sb.append(preOrder(p.getRightNode()));
       }
       return sb.toString();
    }

    /**
     * 中根遍历，先遍历左节点，根节点，右节点
     * @return
     */
    private String inOrder(){
        String s= inOrder(root).toString();
        if(s.length() > 0){
            s = s.substring(0,s.length() - 1);
        }
        return s;
    }

    /**
     * 中根遍历
     * @return
     */
    private String inOrder(BinaryNode<T> p){
      StringBuffer sb = new StringBuffer();
      if(p != null){
          sb.append(inOrder(p.getLeftNode()));
          sb.append(p.getData()).append(",");
          sb.append(inOrder(p.getRightNode()));
      }
      return sb.toString();
    }

    /**
     * 后根遍历，先遍历左子树，右子树，根节点
     * @return
     */
    public String postOrder(){
        String s= postOrder(root).toString();
        if(s.length() > 0){
            s = s.substring(0,s.length() - 1);
        }
        return s;
    }

    /**
     * 后根遍历
     * @param p
     * @return
     */
    public String postOrder(BinaryNode<T> p){
        StringBuffer sb = new StringBuffer();
        if(p != null){
            //先遍历左子树
            sb.append(postOrder(p.getLeftNode()));
            //再便利右子树
            sb.append(postOrder(p.getRightNode()));
            sb.append(p.getData()).append(",");
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        BinarySearchTree<Integer> rootNode = new BinarySearchTree<Integer>();
        rootNode.insert(7);
        rootNode.insert(2);
        rootNode.insert(9);
        rootNode.insert(1);
        rootNode.insert(5);
        rootNode.insert(8);
        rootNode.insert(3);
        rootNode.insert(4);
        System.out.println(rootNode);
        System.out.println("tree hight=" + rootNode.hight());
        rootNode.remove((Integer) 2,rootNode.getRoot());
        System.out.println(rootNode);
        System.out.println("tree hight=" + rootNode.hight());
        System.out.println("tree size=" + rootNode.size());
        System.out.println("preOrder tree=" + rootNode.preOrder());
        System.out.println("inOrder tree=" + rootNode.inOrder());
        System.out.println("postOrder tree=" + rootNode.postOrder());
    }
}