二叉树的几种遍历方式

面试被问到树的遍历，结果一下没记起来= =，在此记录下。

常见的遍历方式

先序遍历、中序遍历、后序遍历、 层次遍历等。

先序遍历

从根节点开始读取，沿着左子树依次往下读取，直到左子树的子树为空，再读取该左子树双亲节点的右子树。重复上述过程直到遍历完所有节点。

概括：从根节点开始 --> 左子树 --> 双亲节点 --> 右子树。

中序遍历

从最左边的叶子节点开始遍历，然后遍历双亲结点，再读取双亲结点的右子树。重复上述过程依次读取直到遍历完所有节点。

概括：最左边的叶子节点开始 --> 双亲节点 --> 右子树。

后序遍历

从最左边的叶子节点开始遍历，然后遍历双亲节点的右子树，再遍历双亲节点。

概括：最左边的叶子节点开始 --> 右子树 --> 双亲节点。

层次遍历

从根节点开始，逐层向下读取。

简单实现

树的类

public class MyTree {
    //节点数据
    String str;
    //左右子节点
    MyTree left;
    MyTree right;

    //set/get方法
    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    public MyTree getLeft() {
        return left;
    }

    public void setLeft(MyTree left) {
        this.left = left;
    }

    public MyTree getRight() {
        return right;
    }

    public void setRight(MyTree right) {
        this.right = right;
    }

    public MyTree(String str, MyTree left, MyTree right) {
        this.str = str;
        this.left = left;
        this.right = right;
    }

    public MyTree(String str) {
        this.str = str;
    }
}

测试及代码实现

测试用的树

public class Test {

    public static void main(String args[]){
        //构建树
        MyTree A = new MyTree("A");/根节点                            
        MyTree B = new MyTree("B");//                                        
        MyTree C = new MyTree("C");//           
        MyTree D = new MyTree("D");//               
        MyTree E = new MyTree("E");//
        MyTree F = new MyTree("F");//
        MyTree G = new MyTree("G");//
        MyTree H = new MyTree("H");//
        MyTree I = new MyTree("I");//
        MyTree J = new MyTree("J");//
        MyTree K = new MyTree("K");//

        A.setLeft(B);
        A.setRight(C);
        B.setLeft(D);
        B.setRight(E);
        C.setLeft(F);
        C.setRight(G);
        D.setLeft(H);
        D.setRight(I);
        E.setRight(J);
        F.setRight(K);

        System.out.println("先序遍历： ");
        preorderTraversal(A);

        System.out.println("中序遍历： ");
        inorderTraversal(A);

        System.out.println("后序遍历： ");
        postorderTraversal(A);

        System.out.println("层次遍历： ");
        levelTraversal(A);
    }

    //先序遍历
    public static void preorderTraversal(MyTree tree) {
        if(tree != null) {
            System.out.println(tree.str);//访问节点数据
            preorderTraversal(tree.left);//访问左节点
            preorderTraversal(tree.right);//访问右节点
        }
    }

    //中序遍历
    public static void inorderTraversal(MyTree tree) {
        if(tree != null) {
            inorderTraversal(tree.left);//访问左节点
            System.out.println(tree.str);//访问节点数据
            inorderTraversal(tree.right);//访问右节点
        }
    }

    //后序遍历
    public static void postorderTraversal(MyTree tree) {
        if(tree != null) {
            postorderTraversal(tree.left);//访问左节点
            postorderTraversal(tree.right);//访问右节点
            System.out.println(tree.str);//访问节点数据
        }
    }
	//非递归实现 -- 使用栈实现
    public void preorderTraversal2() {
		//代码略
    }

    //层次遍历 -- 考虑用队列实现
    public static void levelTraversal(MyTree tree) {
		//代码略
    }


}