二叉树的前序、中序、后序遍历（附java代码）

前序、中序、后序遍历思想

1. 前序遍历的顺序是根左右，即先遍历根节点，接着遍历左节点，最后遍历右节点；
2. 中序遍历的顺序是左根右，即先遍历左节点，接着遍历根节点，最后遍历右节点；
3. 后序遍历的顺序是左右根，即先遍历左节点，接着遍历右节点，最后遍历根节点。
4. 总结：前序、中序、后序遍历就是看访问根节点的位置。

 举例说明

 假设一颗如图所示的二叉树，如何写出前序、中序、后序遍历呢？

 我们可以将上图转化为如图所示的一个个子二叉树。

那么根据前序遍历的特点（根左右），先A->B，这时，将B作为根节点，遍历B的左子树，即B->D，此时，D已是叶子节点，接着遍历B的右子树，B->E，此时，E也是叶子节点了，并且对于A来说，左子树已全部遍历完毕，接着遍历A的右子树，A->C，这时，将C作为根节点，遍历C的左子树，C->F，此时，F已是叶子节点，又C没有右子树，那么对于A节点来说右子树也遍历完成，结束，遍历顺序为：A->B->D->E->C->F。

同样，依据中序遍历的特点（左根右），可以写出遍历顺序为：D->B->E->A->F->C。

最后，依据后序遍历特点（左右根），可以写出遍历顺序为：D->E->B->F->C->A。

代码实现

首先，我们需要利用代码定义一颗二叉树，即表述出节点之间的关系，代码如下：

class TreeNode {
    //存入的值
    String value;
    //左子树父节点，默认是null
    TreeNode left;
    //右子数父节点，默认是null
    TreeNode right;

    public TreeNode(String value) {
        this.value = value;
    }

    public TreeNode(String value, TreeNode left, TreeNode right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }
}

前序遍历代码（递归法）：

    //前序遍历   
    public void preOrder() {
        //先输出父节点
        System.out.print(this.value + " ");
        //递归左子树
        if (this.left != null) {
            this.left.preOrder();
        }
        //递归右子树
        if (this.right != null) {
            this.right.preOrder();
        }
    }

中序遍历代码（递归法）：

    //中序遍历
    public void midOrder() {
        //递归左节点
        if (this.left != null) {
            this.left.midOrder();
        }
        //输出父节点
        System.out.print(this.value + " ");
        //递归右节点
        if (this.right != null) {
            this.right.midOrder();
        }
    }

后序遍历代码（递归法）：

    //右序遍历
    public void afterOrder() {
        //递归左节点
        if (this.left != null) {
            this.left.afterOrder();
        }
        //递归右节点
        if (this.right != null) {
            this.right.afterOrder();
        }
        //输出父节点
        System.out.print(this.value + " ");
    }

 整体代码：

public class Solution {
    public static void main(String[] args) {
        //创建节点
        TreeNode rootA = new TreeNode("A");
        TreeNode nodeB = new TreeNode("B");
        TreeNode nodeC = new TreeNode("C");
        TreeNode nodeD = new TreeNode("D");
        TreeNode nodeE = new TreeNode("E");
        TreeNode nodeF = new TreeNode("F");
        //描述关系
        rootA.left = nodeB;
        rootA.right = nodeC;
        nodeB.left = nodeD;
        nodeB.right = nodeE;
        nodeC.left = nodeF;

        System.out.print("前序遍历->");
        rootA.preOrder();

        System.out.println();

        System.out.print("中序遍历->");
        rootA.midOrder();

        System.out.println();

        System.out.print("后序遍历->");
        rootA.afterOrder();
    }
}

class TreeNode {
    //存入的值
    String value;
    //左子树父节点，默认是null
    TreeNode left;
    //右子数父节点，默认是null
    TreeNode right;

    public TreeNode(String value) {
        this.value = value;
    }

    public TreeNode(String value, TreeNode left, TreeNode right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }

    //前序遍历
    public void preOrder() {
        //先输出父节点
        System.out.print(this.value + " ");
        //递归左子树
        if (this.left != null) {
            this.left.preOrder();
        }
        //递归右子树
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    //中序遍历
    public void midOrder() {
        //递归左节点
        if (this.left != null) {
            this.left.midOrder();
        }
        //输出父节点
        System.out.print(this.value + " ");
        //递归右节点
        if (this.right != null) {
            this.right.midOrder();
        }
    }

    //右序遍历
    public void afterOrder() {
        //递归左节点
        if (this.left != null) {
            this.left.afterOrder();
        }
        //递归右节点
        if (this.right != null) {
            this.right.afterOrder();
        }
        //输出父节点
        System.out.print(this.value + " ");
    }
}

测试结果：