二叉树基本操作

package 二叉树;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

/**
 * Created by fz on 2019/1/13.
 */
public class BTR<E extends Comparable<E>> {
   private class Node{
       private E e;
       private Node left;
       private Node right;

       public Node(E e){
           this.e = e;
       }
   }
    private Node root;
    private int size;


    private int size(){
        return size;
    }

    /**
     * 新增一个元素
     * @param e
     */
    public void add(E e){
        root = add(root,e);
        size++;
    }

    private Node add(Node node,E e){
        if(node==null){
            return new Node(e);
        }
        if(node.e.compareTo(e)<0){
            node.right = add(node.right,e);
        }
        if(node.e.compareTo(e)>0){
            node.left = add(node.left,e);
        }
        return node;
    }

    /**
     * 查询 元素是否在二叉树中
     * @param e
     * @return
     */
    public boolean contains(E e){
        return contains(root,e);
    }

    private boolean contains(Node node,E e){
        if(node==null){
            return false;
        }
        if(node.e.compareTo(e)==0){
            return true;
        }
        if(node.e.compareTo(e)>0){
            return contains(node.left,e);
        }
        return contains(node.right,e);
    }

    /**
     * 前序遍历 中-左右
     */
    public void preOrder(){
        preOrder(root);
    }
    private void preOrder(Node node){
        if(node==null){
            return;
        }
        System.out.println(node.e);
        middleOrder(node.left);
        middleOrder(node.right);
    }
    /**
     * 中序遍历 左-中-右
     */
    public void middleOrder(){
        middleOrder(root);
    }

    private void middleOrder(Node node){
        if(node==null){
            return;
        }
        middleOrder(node.left);
        System.out.println(node.e);
        middleOrder(node.right);
    }

    /**
     *前序遍历，使用非递归方式
     */
    public void preNT(){
        Stack<Node> stack = new Stack<Node>();
        stack.push(root);
        while (!stack.isEmpty()){
            Node node = stack.pop();
            System.out.println(node.e);
            if (node.right!=null){
                stack.push(node.right);
            }
            if(node.left!=null){
                stack.push(node.left);
            }
        }
    }

    /*
      *广度优先遍历也叫层序遍历
     */
    public void levelOrder(){
        Queue<Node> linkedList = new LinkedList<Node>();
        linkedList.add(root);
        while(!linkedList.isEmpty()){
            Node node = linkedList.remove();

            System.out.println(node.e);
            if(node.left!=null){
                linkedList.add(node.left);
            }
            if(node.right!=null)
            linkedList.add(node.right);
        }
    }

    /**
     * 获取二叉树最小元素
     * @return
     */
    public Node minNode(){
       return minNode(root);
    }
    private Node minNode(Node node){
        if(node!=null){
            return minNode(node.left);
        }
        return node;
    }

    /**
     * 获取二叉树中最大元素
     * @return
     */
    public Node maxNode(){
        return maxNode(root);
    }
    private Node maxNode(Node node){
        if(node!=null){
            return maxNode(node.right);
        }
        return node;
    }
    /**
     * 删除二叉树中最小节点 并返回最小元素
     * 先找到最小元素保存下来，然后在遍历删除
     */
    public Node removeMinNode(){
        if (root==null){
            return null;
        }
        //找到最小节点
        Node minNode = minNode();
        //删除最小节点
        removeMinNode(root);
        size--;
        return minNode;
    }

    /**
     * 给定一个节点，沿着这个节点查找,删除最小节点后，返回这棵树
     * @param node
     * @return
     */
    private Node removeMinNode(Node node){
       if(node.left==null){
           Node right = node.right;
           node.left=null;
           return right;
       }
        node.left =removeMinNode(node.left);
        return node;
    }

    /**
     * 删除任意节点(得分为三种情况处理)
     * 1.该节点为叶子节点
     * 2.该节点只有左子树
     * 3.该节点只有右子数
     * 4.该节点既有左子数又有右子数
     * @param e
     * @return
     */
    public Node removeNode(E e){
        Node node = removeNode(root, e);
        if(node!=null){
            size--;
        }
        return node;
    }

    /**
     * 1.先找到该元素
     * @param node
     * @param e
     * @return
     */
    public Node removeNode(Node node,E e){
        if(node==null){
            return null;
        }
        //该元素可能位于node的right
        if(node.e.compareTo(e)<0){
            node.right = removeNode(node.right,e);
            return node;
        }
        //该元素可能位于node的left
        if(node.e.compareTo(e)>0){
            node.left = removeNode(node.left,e);
            return node;
        }
        //已经找到了该元素
        //该元素没有左子数
        if(node.left==null){
            Node right = node.right;
            node.right=null;
            return right;
        }
        //该元素没有右子树
        if(node.right==null){
            Node left = node.left;
            node.left=null;
            return left;
        }
        /*
         *该元素既有左子树，又有右子树,两种做法
         * 1.将该节点的右子树下的最小元素顶替待删除节点的位置
         * 2.将该节点的左子树下最大元素顶替待删除节点的位置
         */
        Node right = node.right;
        Node left = node.left;
        //采取第一种做法
        //获取右子树最小节点
        Node successtor = minNode(right);
        successtor.left = left;
        successtor.right = removeMinNode(right);
        //删除原节点的引用
        node.right=null;
        node.left=null;
        return successtor;
    }
}