用java实现二叉树的相关操作

public class TestTree {

    private TreeNode root = null;


    public TestTree(){
        root = new TreeNode(1,"A");
    }

    public TreeNode getRoot() {
        return root;
    }

    public void setRoot(TreeNode root) {
        this.root = root;
    }



    //    构建二叉树
    /**
     *           A
     *        B    C
     *      D  E     F
     *
     * */
    public void createBinaryTree(){
        TreeNode nodeB = new TreeNode(2,"B");
        TreeNode nodeC = new TreeNode(3,"C");
        TreeNode nodeD = new TreeNode(4,"D");
        TreeNode nodeE = new TreeNode(5,"E");
        TreeNode nodeF = new TreeNode(6,"F");
        root.setLeftChild(nodeB);
        root.setRightChild(nodeC);
        nodeB.setLeftChild(nodeD);
        nodeB.setRightChild(nodeE);
        nodeC.setRightChild(nodeF);
    }

//    求树的高度
    //先计算A结点的左子树的高度，再计算A结点的右子树的高度
    //最后两个高度进行判断然后加1
    public int getHeight(){
        return getHeight(root);
    }

    public int getHeight(TreeNode root1){
        if(root1 == null){
            return 0;
        }else{
            int i = getHeight(root1.getLeftChild());
            int j = getHeight(root1.getRightChild());
            return (i < j) ? j+1 : i+1;
        }
    }

    //求二叉树的结点数
    public int getSize(){
        return getSize(root);
    }

    public int getSize(TreeNode node){
        if(node == null){
            return 0;
        }else{
            return 1 + getSize(node.getLeftChild()) + getSize(node.getRightChild());
        }
    }

//    前序遍历
    public void preOrder(TreeNode node){
        if(node == null){
            return ;
        }else{
            System.out.println("preOrder data:" + node.getData());
            preOrder(node.getLeftChild());
            preOrder(node.getRightChild());
        }
    }


    /**
     * 通过前序遍历的数据序列反向生成二叉树
     *              A
     *         B        C
     *     D     E    #   F
     *   #   #  #  #    #   #
     *
     *   ABD##E##C#F##
     *
     * */
    public void createBinaryTreePre(ArrayList<String> data){
            createBinaryTree(data.size(),data);
    }

    public TreeNode createBinaryTree(int size,ArrayList<String> data){
        if(data.size() == 0){
            return null;
        }
        int index = size - data.size();
        String d = data.get(0);
        TreeNode node = new TreeNode(index,data);
        if(d.equals("#")){
            node = null;
            data.remove(0);
            return node;
        }
        if(index == 0){
            //创建根结点
            root = node;

        }
            data.remove(0);
            node.setLeftChild(createBinaryTree(size,data));
            node.setRightChild(createBinaryTree(size,data));



        return node;
    }








//    中序遍历
    public void minOrder(TreeNode node){
        if(node == null){
            return ;
        }else{
            preOrder(node.getLeftChild());
            System.out.println("preOrder data:" + node.getData());
            preOrder(node.getRightChild());
        }
    }

    //后序遍历
    public void postOrder(TreeNode node){
        if(node == null){
            return ;
        }else{
            postOrder(node.getLeftChild());
            postOrder(node.getRightChild());
            System.out.println("postOrder data:" + node.getData());
        }
    }

    //通过栈来实现前序遍历
    public void nonPreOrder(TreeNode node){
        Stack<TreeNode> stack = new Stack<>();
        stack.push(node);
        while(!stack.isEmpty()){
            TreeNode n = stack.pop();
            System.out.println("nonPreOrder data:" + n.getData());
            if(node.getRightChild() != null) {
                stack.push(node.getRightChild());//先将右结点入栈
            }
            if(node.getLeftChild() != null) {
                stack.push(node.getLeftChild());//再将左结点入栈
            }
        }
    }

    //通过栈实现中序遍历
    public void createBinaryMidTreeByStack(TreeNode node){
        Stack<TreeNode> stack = new Stack<>();
        stack.push(node);
        while(!stack.isEmpty()) {
            while(stack.peek() != null){
                stack.push(stack.peek().getLeftChild());
            }
            stack.pop();
            if(!stack.isEmpty()){
                node = stack.pop();
                System.out.println("MidOrder data:" + node.getData());
                stack.push(node.getRightChild());
            }

        }
    }

    //通过栈实现后序遍历
    public void createBinaryTreePostByStack(TreeNode node){
        TreeNode n = null;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(node);
        boolean flag;   //当压入栈后为true，判断压入的结点是否还有右子树
        while(!stack.isEmpty()){
            while(stack.peek() != null){
                stack.push(stack.peek().getLeftChild());
            }
            stack.pop();
            while (!stack.isEmpty()){
                node = stack.peek();
                if(node.getRightChild() == null || n == node.getRightChild()) {
                    System.out.println("PostOrder Data:" + node.getData());
                    n = node;
                    stack.pop();
                    flag = false;
                }else{
                    stack.push(node.getRightChild());
                    flag = true;
                }

                if(flag){
                    break;
                }
            }
        }
    }

    public int sum(int[] arr,int n){
        if(n == 0){
            return arr[0];
        }
        return sum(arr,n - 1) + arr[n];

    }

    //求数组中的最大值
    public static int max(int[] arr,int n){
        if(n == 0){
            return arr[0];
        }else{
            if(max(arr,n - 1 - 1) > arr[n - 1]){
                return max(arr,n - 1 - 1);
            }else{
                return arr[n - 1];
            }
        }
    }



    public static void main(String[] args){
//        int[] arr = new int[]{1,2,4,9,4,5,6,0};
//        int num = max(arr,arr.length);
//        System.out.println(num);
          TestTree t = new TestTree();
          t.createBinaryTree();
//          t.nonPreOrder(t.getRoot());
        t.createBinaryTreePostByStack(t.getRoot());
    }
}
public class TreeNode<T> {

    private int index;
    private T data;
    private TreeNode leftChild;
    private TreeNode rightChild;
    private TreeNode parent;

    public TreeNode(int index,T data){
        this.index = index;
        this.data = data;
        this.leftChild = null;
        this.rightChild = null;
    }

    public TreeNode getParent() {
        return parent;
    }

    public void setParent(TreeNode parent) {
        this.parent = parent;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public TreeNode<T> getLeftChild() {
        return leftChild;
    }

    public void setLeftChild(TreeNode<T> leftChild) {
        this.leftChild = leftChild;
    }

    public TreeNode<T> getRightChild() {
        return rightChild;
    }

    public void setRightChild(TreeNode<T> rightChild) {
        this.rightChild = rightChild;
    }
}