二叉树的4种遍历方法

二叉树的遍历方法分为前中后序遍历，另外还有一种层序遍历，算法如下：

/**
 * 构造二叉树
 */
public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;

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

/**
 * 前序遍历，递归实现
 */
public void preOrder(TreeNode node) {
    if (node != null) {
        System.out.print(node.val);
        preOrder(node.left);
        preOrder(node.right);
    }
}

/**
 * 前序遍历，非递归实现
 * 1. 先入栈根节点，输出根节点val值，再先后入栈其右节点、左结点；
 * 2. 出栈左节点，输出其val值，再入栈该左节点的右节点、左节点；直到遍历完该左节点所在子树。
 * 3. 再出栈右节点，输出其val值，再入栈该右节点的右节点、左节点；直到遍历完该右节点所在子树。
 */
public void preOrder1(TreeNode root) {
    Stack<TreeNode> stack = new Stack<>();
    if (root != null) {
        stack.push(root);
    }
    while (!stack.isEmpty()) {
        TreeNode 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 void inOrder(TreeNode node) {
    if (node != null) {
        inOrder(node.left);
        System.out.print(node.val);
        inOrder(node.right);
    }
}

/**
 * 中序遍历，非递归实现
 *  1. 首先从根节点出发一路向左，入栈所有的左节点；
 *  2. 出栈一个节点，输出该节点val值，查询该节点是否存在右节点，
 *     若存在则从该右节点出发一路向左入栈该右节点所在子树所有的左节点；
 *  3. 若不存在右节点，则出栈下一个节点，输出节点val值，同步骤2操作；
 *  4. 直到节点为null，且栈为空。
 */
public void inOrder1(TreeNode root) {
    Stack<TreeNode> stack = new Stack<>();
    while (root != null || !stack.isEmpty()) {
        while (root != null) {
            stack.push(root);
            root = root.left;
        }
        if (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            System.out.print(node.val);
            root = node.right;
        }
    }
}

/**
 * 后序遍历，递归实现
 */
public void postOrder(TreeNode node) {
    if (node != null) {
        postOrder(node.left);
        postOrder(node.right);
        System.out.print(node.val);
    }
}

/**
 * 后序遍历，非递归实现
 *  后序遍历的难点在于：需要判断上次访问的节点是位于左子树，还是右子树
 *  若是位于左子树，则需要跳过根节点，先进入右子树，再回头访问跟节点
 *  若是位于右子树，则直接访问根节点
 */
public static void postOrder1(TreeNode root) {
    if (root == null) {
        return;
    }
    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode cur = root;
    TreeNode pre = null;

    //移到最左边
    while (cur != null) {
        stack.push(cur);
        cur = cur.left;
    }

    while (!stack.empty()) {
        cur = stack.pop();

        //一个根节点被访问的前提是：无右子树或右子树已被访问过
        if (cur.right != null && cur.right != pre) {
            stack.push(cur);
            cur = cur.right;
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
        } else {
            System.out.print(cur.val);
            pre = cur;
        }
    }
}

/**
 * 层序遍历（广度优先遍历）
 */
public void layerOrder(TreeNode root) {
    Queue<TreeNode> queue = new ArrayDeque<>();
    if (root != null) {
        queue.offer(root);
    }
    while (!queue.isEmpty()) {
        TreeNode node = queue.poll();
        System.out.print(node.val);
        if (node.left != null) {
            queue.offer(node.left);
        }
        if (node.right != null) {
            queue.offer(node.right);
        }
    }
}

/**
 * 二叉树遍历测试，遍历如下二叉树
 *    1
 *   /  \
 *  2    3
 * / \  / \
 * 4  5 6  7
 */
@Test
public void testTraversal() {
    TreeNode node1 = new TreeNode(1);
    TreeNode node2 = new TreeNode(2);
    TreeNode node3 = new TreeNode(3);
    TreeNode node4 = new TreeNode(4);
    TreeNode node5 = new TreeNode(5);
    TreeNode node6 = new TreeNode(6);
    TreeNode node7 = new TreeNode(7);

    node1.left = node2;
    node1.right = node3;

    node2.left = node4;
    node2.right = node5;

    node3.left = node6;
    node3.right = node7;

    postOrder1(node1);
}

遍历结果：