3.1分别用递归和非递归方式实现二叉树先序、中序和后序遍历

题目

用递归和非递归方式，分别按照二叉树先序、中序和后序打印所有的节点。

首先给出二叉树节点结构定义：

public class BinaryTreeNode {
    //二叉树节点
    private int data;
    private BinaryTreeNode left;
    private BinaryTreeNode right;

    public int getData() {
        return data;
    }

    public BinaryTreeNode getLeft() {
        return left;
    }

    public BinaryTreeNode getRight() {
        return right;
    }
}

三种遍历的递归实现如下：

//前序遍历递归的方式
public void preOrder(BinaryTreeNode root) {
    if (null != root) {
        System.out.print(root.getData() + "\t");
        preOrder(root.getLeft());
        preOrder(root.getRight());
    }
}

//中序遍历采用递归的方式
public void inOrder(BinaryTreeNode root) {
    if (null != root) {
        inOrder(root.getLeft());
        System.out.print(root.getData() + "\t");
        inOrder(root.getRight());
    }
}

//后序遍历采用递归的方式
public void postOrder(BinaryTreeNode root) {
    if (root != null) {
        postOrder(root.getLeft());
        postOrder(root.getRight());
        System.out.print(root.getData() + "\t");
    }
}

用递归方法解决的问题都能用非递归的方法实现。这是因为递归方法无非就是利用函数栈来保存信息，如果用自己申请的数据结构来代替函数栈，也可以实现相同的功能。

用非递归的方式实现二叉树的先序遍历：

/**
 * 前序遍历非递归的方式
 * 
 * 1.申请一个新的栈，记为stack。然后将头节点root压入stack中。
 * 2.从stack中弹出栈顶节点，记为cur，然后打印cur节点的值，再将节点cur的右孩子（不为空的话）先压入stack中，最后将cur的左孩子（不为空的话）压入stack中。
 * 3.不断重复步骤2，直到stack为空，全部过程结束。
 *
 * @param root 根节点
 */
public void preOrderNonRecursive(BinaryTreeNode root) {
    if (root != null) {
        Stack<BinaryTreeNode> stack = new Stack<>();
        stack.add(root);
        while (!stack.isEmpty()) {
            root = stack.pop();
            System.out.print(root.getData() + "\t");
            if (root.getRight() != null) {
                stack.push(root.getRight());
            }
            if (root.getLeft() != null) {
                stack.push(root.getLeft());
            }
        }
    }
    System.out.println();
}

用非递归的方式实现二叉树的中序遍历：

/**中序遍历采用非递归的方式
 * 
 * 1.申请一个新的栈，记为stack。初始时，令变量cur=root。
 * 2.先把cur节点压入栈中，对以cur节点为根的整颗子树来说，依次把左边界压入栈中，即不停地令cur=cur.getLeft(),然后重复步骤2。
 * 3.不断重复步骤2，直到发现cur为空，此时从stack中弹出一个节点，记为node。打印node的值，并且让cur=node.getRight()，然后继续重复步骤2。
 * 4.当stack为空且cur为空时，整个过程停止。
 * 
 * @param root 根节点
 */
public void inOrderNonRecursive(BinaryTreeNode root) {
    if (root != null) {
        Stack<BinaryTreeNode> stack = new Stack<>();
        while (!stack.isEmpty() || root != null) {
            if (root != null) {
                stack.push(root);
                root = root.getLeft();
            } else {
                root = stack.pop();
                System.out.print(root.getData() + "\t");
                root = root.getRight();
            }
        }
    }
    System.out.println();
}

用非递归的方式实现二叉树的后序遍历：

/**后序遍历采用非递归的方式
 * 
 * 用两个栈实现
 * 1.申请两个栈，分别记为s1，s2，然后将头节点root压入s1中。
 * 2.从s1中弹出的节点记为cur，然后依次将cur的左孩子和右孩子压入s1中。
 * 3.在整个过程中，每一个从s1中弹出的节点都放进s2中。
 * 4.不断重复步骤2和步骤3，直到s1为空，过程停止。
 * 5.从s2中依次弹出节点并打印，打印的顺序就是后序遍历的顺序。
 * 
 * @param root 根节点
 */
public void postOrderNonRecursive(BinaryTreeNode root) {
    if (root != null) {
        Stack<BinaryTreeNode> s1 = new Stack<>();
        Stack<BinaryTreeNode> s2 = new Stack<>();
        s1.push(root);
        while (!s1.isEmpty()) {
            root = s1.pop();
            s2.push(root);
            if (root.getLeft() != null) {
                s1.push(root.getLeft());
            }
            if (root.getRight() != null) {
                s1.push(root.getRight());
            }
        }
        while (!s2.isEmpty()) {
            System.out.print(s2.pop().getData() + "\t");
        }
    }
    System.out.println();
}