二叉树的前序、中序和后序遍历

前序的访问顺序就是根-左-右
中序的访问顺序是左-根-右
后序的访问顺序是左-右-根
递归实现是很简单的，只需要调节代码的顺序就行了
前序递归：

	List<Integer> result=new ArrayList<>();

    public List<Integer> preorderTraversal(TreeNode root) {
        if(root!=null){
        	//根-左-右
            result.add(root.val);
            preorderTraversal(root.left);
            preorderTraversal(root.right);
        }
        return result;
    }

中序递归：

	List<Integer> result=new ArrayList<>();

    public List<Integer> inorderTraversal(TreeNode root) {
        if(root!=null){
        	//左-根-右
            inorderTraversal(root.left);
            result.add(root.val);
            inorderTraversal(root.right);
        }
        return result;
    }

后序递归：

	List<Integer> result=new ArrayList<>();

    public List<Integer> postorderTraversal(TreeNode root) {
        if(root!=null){
        	//左-右-根
            postorderTraversal(root.left);
            postorderTraversal(root.right);
            result.add(root.val);
        }
        return result;
    }

非递归就稍微复杂一些
前序非递归：

	public List<Integer> preorderTraversal(TreeNode root) {
        Stack<TreeNode> stack=new Stack<>();
        List<Integer> list=new ArrayList<>();
        while(!stack.isEmpty()||root!=null){
            //root不为空就添加到结果集并入栈，再指向左节点
            if(root!=null){
                list.add(root.val);
                stack.push(root);
                root=root.left;
            }else{//root为空就出栈，指向右节点
                TreeNode pop=stack.pop();
                root=pop.right;
            }
        }
        return list;
    }

中序非递归：

	public List<Integer> inorderTraversal(TreeNode root) {
        //递归比较简单，使用非递归，利用栈
        Stack<TreeNode> stack=new Stack<>();
        List<Integer> list=new ArrayList<>();
        while(!stack.isEmpty()||root!=null){
            //root不为空就入栈，再指向左节点
            if(root!=null){
                stack.push(root);
                root=root.left;
            }else{//root为空就出栈，加入结果集，指向右节点
                TreeNode pop=stack.pop();
                list.add(pop.val);
                root=pop.right;
            }
        }
        return list;
    }

后序非递归：

	public List<Integer> postorderTraversal(TreeNode root) {
        Stack<TreeNode> stack=new Stack<>();
        LinkedList<Integer> list=new LinkedList<>();
        if(root==null)
            return list;
        //从上到下，从左至右将节点入栈,依次出栈,得到的结果反向输出即可
        stack.add(root);
        while(!stack.isEmpty()){
            TreeNode pop=stack.pop();
            //总是将结果添加到头部，相当于反转了结果
            list.addFirst(pop.val);
            //左节点不为空入栈
            if(pop.left!=null)
                stack.push(pop.left);
            //右节点不为空入栈
            if(pop.right!=null)
                stack.push(pop.right);
        }
        return list;
    }