树的前、中、后序遍历

import java.util.Stack;

/**
 * @Author: 
 * @Date: 2018/9/28 11:36
 */

public class TreeSort {
    public static void main(String[] args) {
        TreeNode level4_1 = new TreeNode(8,null,null);
        TreeNode level4_2 = new TreeNode(9,null,null);
        TreeNode level3_1 = new TreeNode(4,null,null);
        TreeNode level3_2 = new TreeNode(5,level4_1,level4_2);
        TreeNode level3_3 = new TreeNode(6,null,null);
        TreeNode level3_4 = new TreeNode(7,null,null);
        TreeNode level2_1 = new TreeNode(2,level3_1,level3_2);
        TreeNode level2_2 = new TreeNode(3,level3_3,level3_4);
        TreeNode root = new TreeNode(1,level2_1,level2_2);
        Stack<TreeNode> stack = new Stack();
        preOrderSort(stack,root.getLeft(),root,root.getRight());
        System.out.println("前-----------");
        while(stack.size()!=0) {
            System.out.println(stack.pop().getVal());
        }
        System.out.println("中-----------");

        midOrderSort(stack,root.getLeft(),root,root.getRight());
        while(stack.size()>0) {
            System.out.println(stack.pop().getVal());
        }
        System.out.println("后-----------");
        backOrderSort(stack,root.getLeft(),root,root.getRight());
        while(stack.size()!=0) {
            System.out.println(stack.pop().getVal());
        }
        System.out.println("深度-----------="+depthTree(root));
        System.out.println("宽度-----------="+widthTree(root));

    }

    private static int widthTree(TreeNode root) {
        Stack<TreeNode> cStack = new Stack<>();
        cStack.push(root);
        int maxWidth = cStack.size();
        while(true) {
            Stack<TreeNode> stack = new Stack<>();
            while(cStack.size()>0) {
                TreeNode node = cStack.pop();
                TreeNode nodeLeft = node.getLeft();
                if(nodeLeft!=null) {
                    stack.push(nodeLeft);
                }
                TreeNode nodeRight = node.getRight();
                if(nodeRight!=null) {
                    stack.push(nodeRight);
                }
            }
            cStack = stack;
            maxWidth = Math.max(maxWidth,stack.size());
            if(stack.size()==0) {
                break;
            }
        }
        return maxWidth;
    }

    private static int depthTree(TreeNode node) {
        if(node!=null) {
            if(node.getLeft()==null && node.getRight() ==null) {
                return 1;
            }else {
                int countLeft = 0;
                if(node.getLeft()!=null) {
                    countLeft = depthTree(node.getLeft());
                }
                int countRight = 0;
                if(node.getRight() !=null) {
                    countRight = depthTree(node.getRight());
                }
                return 1 + Math.max(countLeft,countRight);
            }
        }else {
            return 0;
        }
    }

    private static void backOrderSort(Stack<TreeNode> cStack,TreeNode leftNode,TreeNode node,TreeNode rightNode) {
        if(leftNode!=null) {
            if(leftNode.getLeft()==null) {
                cStack.push(leftNode);
            }else {
                backOrderSort(cStack,leftNode.getLeft(),leftNode,leftNode.getRight());
            }
        }
        if(rightNode!=null) {
            if(rightNode.getLeft()==null && rightNode.getRight()==null ) {
                cStack.push(rightNode);
            }else {
                backOrderSort(cStack,rightNode.getLeft(),rightNode,rightNode.getRight());
            }
        }
        cStack.push(node);
    }

    private static void midOrderSort(Stack<TreeNode> cStack,TreeNode leftNode,TreeNode node,TreeNode rightNode) {
        if(leftNode!=null) {
            if(leftNode.getLeft()==null) {
                cStack.push(leftNode);
            }else {
                midOrderSort(cStack,leftNode.getLeft(),leftNode,leftNode.getRight());
            }
        }
        cStack.push(node);
        if(rightNode!=null) {
            if(rightNode.getLeft()==null && rightNode.getRight()==null ) {
                cStack.push(rightNode);
            }else {
                midOrderSort(cStack,rightNode.getLeft(),rightNode,rightNode.getRight());
            }
        }
    }

    private static void preOrderSort(Stack<TreeNode> cStack,TreeNode leftNode,TreeNode node,TreeNode rightNode) {
        cStack.push(node);
        if(leftNode!=null) {
            if(leftNode.getLeft()==null) {
                cStack.push(leftNode);
            }else {
                preOrderSort(cStack,leftNode.getLeft(),leftNode,leftNode.getRight());
            }
        }
        if(rightNode!=null) {
            if(rightNode.getLeft()==null && rightNode.getRight()==null ) {
                cStack.push(rightNode);
            }else {
                preOrderSort(cStack,rightNode.getLeft(),rightNode,rightNode.getRight());
            }
        }
    }
}

class TreeNode{
    private int val;
    private TreeNode left;
    private TreeNode right;
    public TreeNode(int val,TreeNode left,TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }

    public int getVal() {
        return val;
    }

    public TreeNode getLeft() {
        return left;
    }

    public TreeNode getRight() {
        return right;
    }
}