二叉树的前序、中序、后序、层序遍历 -- 递归及非递归解法

其实二叉树的遍历方式不仅仅只有我们常说的前序遍历、中序遍历和后序遍历，还有一种遍历方式叫做层序遍历，即按照二叉树的每一层顺序打印各个节点。

• 下面将通过代码来实现这四种遍历：

public class TestBinaryTree {

    class TreeNode {
        char value;
        TreeNode left;
        TreeNode right;

        public TreeNode(char value) {
            this.value = value;
        }
    }
	
	public int i = 0;
    //根据字符串创建二叉树
    public TreeNode createTestTree(String s) {
        TreeNode root = null;
        if (s.charAt(i) != '#') {
            root = new TreeNode(s.charAt(i));
            i++;
            root.left = createTestTree(s);
            root.right = createTestTree(s);
        }else {
            i++;
        }
        return root;
    }

    //二叉树的前序遍历递归（根左右）
    public void binaryTreePrevOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        System.out.print(root.value + " ");
        binaryTreePrevOrder(root.left);
        binaryTreePrevOrder(root.right);
    }

    //二叉树的中序遍历递归（左根右）
    public void binaryTreeInOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        binaryTreeInOrder(root.left);
        System.out.print(root.value + " ");
        binaryTreeInOrder(root.right);
    }

    //二叉树的后序遍历递归（左右根）
    public void binaryTreePostOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        binaryTreePostOrder(root.left);
        binaryTreePostOrder(root.right);
        System.out.print(root.value + " ");
    }
	
	//二叉树的前序遍历非递归
    public void binaryTreePrevOrderNonR(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        TreeNode top = null;

        while (cur != null || !stack.empty()) {
            while (cur != null) {
                stack.push(cur);
                System.out.print(cur.value + " ");
                cur = cur.left;
            }
            top = stack.pop();
            cur = top.right;
        }
        System.out.println();
    }

    //二叉树的中序遍历非递归
    public void binaryTreeInOrderNonR(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        TreeNode top = null;

        while (cur != null && !stack.empty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            top = stack.pop();
            System.out.print(top.value + " ");
            cur = top.right;
        }
        System.out.println();
    }

    //二叉树的后序遍历非递归
    public void binaryTreePostOrderNonR(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        TreeNode prev = null;

        while (cur != null && !stack.empty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.peek();
            if (cur.right == null || cur.right == prev) {
                stack.pop();
                System.out.print(cur.value + " ");
                prev = cur;//记录的是是否已经被打印过
                cur = null;
            }else {
                cur = cur.right;
            }
        }
        System.out.println();
    }

    //二叉树的层序遍历
    public void binaryTreeLevelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        if (root != null) {
            queue.offer(root);
        }
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            System.out.print(cur.value + " ");
            if (cur.left != null) {
                queue.offer(cur.left);
            }
            if (cur.right != null) {
                queue.offer(cur.right);
            }
        }
        System.out.println();
    }
}

package com.xxx;

/**
 * Description:
 * Author: admin
 * Create: 2019-06-11 19:48
 */
public class TestDemo {

    public static void main(String[] args) {

        TestBinaryTree testBinaryTree = new TestBinaryTree();

        TestBinaryTree.TreeNode root =
                testBinaryTree.createTestTree("ABC##DE#G##F###");

        //前序遍历
        testBinaryTree.binaryTreePrevOrder(root);
        System.out.println();
        testBinaryTree.binaryTreePrevOrderNonR(root);
        System.out.println("================");

        //中序遍历
        testBinaryTree.binaryTreeInOrder(root);
        System.out.println();
        testBinaryTree.binaryTreeInOrderNonR(root);
        System.out.println("================");

        //后序遍历
        testBinaryTree.binaryTreePostOrder(root);
        System.out.println();
        testBinaryTree.binaryTreePostOrderNonR(root);
        System.out.println("================");

        //层序遍历
        testBinaryTree.binaryTreeLevelOrder(root);
    }
}

由createTestTree("ABC##DE#G##F###")可以得出这棵二叉树的逻辑结构如下：

那么二叉树的各个遍历的结果可以推导出来如下：

• 前序遍历（根左右）：A B C D E G F
• 中序遍历（左跟右）：C B E G D F A
• 后序遍历（左右根）：C G E F D B A
• 层序遍历：A B C D E F G

运行结果：
A B C D E G F 
A B C D E G F 
================
C B E G D F A 
C B E G D F A 
================
C G E F D B A 
C G E F D B A 
================
A B C D E F G