二叉树遍历(先序、中序、后序)

二叉树的相关概念
二叉树的定义
二叉树(Binary Tree)是n(n>=0)个有限元素的集合，该集合或者为空，或者由一个称为根(root)的元素及两个不相交的，被称为左子树和右子树的二叉树组成。当集合为空时，称该二叉树为空二叉树，在二叉树中，一个元素也称为一个结点。
二叉树是有序的，即若将其左右子树颠倒，就称为另一颗不同的二叉树。
结点的度：结点所拥有的子树的个数称为该结点的度。
叶结点：度为0的结点称为叶结点，或者称为终端结点。
树的深度：树中所有结点的最大层数称为树的深度。
树的度：树中个结点度的最大值称为该树的度。
2.二叉树的三种遍历方式
二叉树有三种遍历方式：前序（父节点，左节点，右节点），中序（左节点，父节点，右节点），后序（左节点，右节点，父节点）。

如上图所示的一颗二叉树，按照三种遍历方式所打印的结果应该是：
前序：1 2 4 8 9 5 10 11 3 6 7
中序：8 4 9 2 10 5 11 1 6 3 7
后序：8 9 4 10 11 5 2 6 7 3 1

遍历方式的代码：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args)   {

        TreeNode root =new TreeNode(0);
        TreeNode left=new TreeNode(1);
        TreeNode right=new TreeNode(2);
        TreeNode left2=new TreeNode(3);
        TreeNode right2=new TreeNode(4);
        TreeNode left3=new TreeNode(5);
        TreeNode right3=new TreeNode(6);
        TreeNode left4=new TreeNode(7);
        TreeNode right4=new TreeNode(8);
        left.left=left2;
        left.right=right2;
        right.left=left3;
        right.right=right3;
        root.left=left;
        root.right=right;
        left2.left=left4;
        left2.right=right4;
        Print.PrintTreeNode(root);

        System.out.println("先序遍历：");
        PreOrderTraverse(root);
        System.out.println();
        System.out.println("中序遍历：");
        MidOrderTraverse(root);
        System.out.println();
        System.out.println("后序遍历：");
        LastOrderTraverse(root);
        System.out.println();
    }

    public static void PreOrderTraverse(TreeNode root){
        TreeNode node=root;
        if(node!=null){
            System.out.print(node.val+"   ");
            PreOrderTraverse(node.left);
            PreOrderTraverse(node.right);
        }
    }

    public static void MidOrderTraverse(TreeNode root){
        TreeNode node=root;
        if(node!=null){
            MidOrderTraverse(node.left);
            System.out.print(node.val+"   ");
            MidOrderTraverse(node.right);
        }
    }

    public static void LastOrderTraverse(TreeNode root){
        TreeNode node=root;
        if(node!=null){
            LastOrderTraverse(node.left);
            LastOrderTraverse(node.right);
            System.out.print(node.val+"   ");
        }
    }
}

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}



class Print{
    //打印TreeNode
    public static void PrintTreeNode(TreeNode root){
        ArrayList arrayList=PrintFromTopToBottom(root);
        printTree(arrayList,arrayList.size());
    }
    //转换TreeNode为ArrayList
    private static ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {

        ArrayList<Integer> list = new ArrayList();
        if(root == null)
            return list;

        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);

        while(!queue.isEmpty()){
            TreeNode treeNode = queue.poll();
            list.add(treeNode.val);
            if(treeNode.left != null)
                queue.offer(treeNode.left);
            if(treeNode.right != null)
                queue.offer(treeNode.right);
        }

        return list;
    }

    //以树形打印ArrayList
    private static void printTree(ArrayList array,int len){

        int layers = (int)Math.floor(Math.log((double)len)/Math.log((double)2))+1;  //树的层数
        int maxWidth = (int)Math.pow(2,layers)-1;  //树的最大宽度
        int endSpacing = maxWidth;
        int spacing;
        int numberOfThisLayer;
        for(int i=1;i<=layers;i++){  //从第一层开始，逐层打印
            endSpacing = endSpacing/2;  //每层打印之前需要打印的空格数
            spacing = 2*endSpacing+1;  //元素之间应该打印的空格数
            numberOfThisLayer = (int)Math.pow(2, i-1);  //该层要打印的元素总数

            int j;
            for(j=0;j<endSpacing;j++){
                System.out.print("  ");
            }

            int beginIndex = (int)Math.pow(2,i-1)-1;  //该层第一个元素对应的数组下标
            for(j=1;j<=numberOfThisLayer;j++){
                System.out.print(array.get(beginIndex++)+"");
                for(int k=0;k<spacing;k++){  //打印元素之间的空格
                    System.out.print("  ");
                }
                if(beginIndex == len){  //已打印到最后一个元素
                    break;
                }
            }

            System.out.println();
        }
        System.out.println();
    }

}

              0                              
      1              2              
  3      4      5      6      
7  8  

先序遍历：
0   1   3   7   8   4   2   5   6   
中序遍历：
7   3   8   1   4   0   5   2   6   
后序遍历：
7   8   3   4   1   5   6   2   0   

Process finished with exit code 0

非遍历方式的代码：

先序遍历：

   public static void PreOrderTraverse(TreeNode root) {
        TreeNode node = root;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while(node!=null||!stack.isEmpty()){
            while(node!=null){
                System.out.print(node.val+"   ");
                stack.push(node);
                node=node.left;
            }
            if(!stack.isEmpty()){
                node=stack.pop();
                node=node.right;
            }
        }
    }

    public static void PreOrderTraverse2(TreeNode root){
        Stack<TreeNode> stack=new Stack<TreeNode>();
        TreeNode node=root;
        stack.push(node);
        while(!stack.isEmpty()){
            node=stack.pop();
            System.out.print(node.val+"   ");
            if(node.right!=null) {
             stack.push(node.right);
            }
            if(node.left!=null){
                stack.push(node.left);
            }
        }
    }

第二种方式比较容易，效率也应该高一些。

中序遍历：

    public static void MidOrderTraverse(TreeNode root){
        TreeNode node = root;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while(node!=null||!stack.isEmpty()){
            while(node!=null){

                stack.push(node);
                node=node.left;
            }
            if(!stack.isEmpty()){
                node=stack.pop();
                System.out.print(node.val+"   ");
                node=node.right;
            }
        }
    }

后序遍历：

    // 非递归后序遍历
    public static void LastOrderTraverse(TreeNode root) {
        Stack<TreeNode> treeNodeStack = new Stack<TreeNode>();
        TreeNode node = root;
        TreeNode lastVisit = root;
        while (node != null || !treeNodeStack.isEmpty()) {
            while (node != null) {
                treeNodeStack.push(node);
                node = node.left;
            }
            //查看当前栈顶元素
            node = treeNodeStack.peek();
            //如果其右子树也为空，或者右子树已经访问
            //则可以直接输出当前节点的值
            if (node.right == null || node.right == lastVisit) {
                System.out.print(node.val + "   ");
                treeNodeStack.pop();
                lastVisit = node;
                node = null;
            } else {
                //否则，继续遍历右子树
                node = node.right;
            }
        }
    }

https://segmentfault.com/a/1190000004853442

http://www.jianshu.com/p/456af5480cee

https://segmentfault.com/a/1190000002606302

http://www.voidcn.com/blog/u013344815/article/p-4677425.html

https://my.oschina.net/u/225373/blog/491589