二叉树的遍历（非递归）

参考http://blog.csdn.net/hackbuteer1/article/details/6583988

import java.util.LinkedList;
import java.util.Scanner;

public class TraverseTree {

  static class TreeNode {
    public int value;
    public TreeNode left;
    public TreeNode right;
  }

  public static void createTree(TreeNode root) {
    if (root == null) {
      return;
    }
    System.out.println("输入" + root.value + "左右儿子的值：");
    Scanner in = new Scanner(System.in);
    int left = in.nextInt();
    int right = in.nextInt();
    if (left == 0) {
      root.left = null;
    } else {
      TreeNode leftChild = new TreeNode();
      leftChild.value = left;
      root.left = leftChild;
    }
    if (right == 0) {
      root.right = null;
    } else {
      TreeNode rightChild = new TreeNode();
      rightChild.value = right;
      root.right = rightChild;
    }
    createTree(root.left);
    createTree(root.right);
  }

  public static void postOrderRecursive(TreeNode root) {
    if (root != null) {
      postOrderRecursive(root.left);
      postOrderRecursive(root.right);
      System.out.print(root.value + " ");
    }
  }

  public static void postOrder(TreeNode root) {
    LinkedList<TreeNode> myStack = new LinkedList<>();
    TreeNode preTraversed = null;// 指向前一个被访问的节点
    TreeNode cur = root; // 指向当前要检查的节点
    while (cur != null || !myStack.isEmpty()) {
      while (cur != null) {
        myStack.push(cur);
        cur = cur.left;
      }
      cur = myStack.peekFirst();
      if (cur.right == null || cur.right == preTraversed) {
        System.out.print(cur.value + " ");
        preTraversed = cur;
        myStack.pop();
        cur = null;
      } else {
        cur = cur.right;
      }
    }
  }

  /**
   * 后序遍历的非递归(双栈法)
   * @param root
   */
  public static void postOrder2Stack(TreeNode root) {
    LinkedList<TreeNode> stack1 = new LinkedList<>();
    LinkedList<TreeNode> stack2 = new LinkedList<>();
    if (root != null) {
      stack1.push(root);
    }
    while (!stack1.isEmpty()) {
      TreeNode top = stack1.pop();
      stack2.push(top);
      if (top.left != null) {
        stack1.push(top.left);
      }
      if (top.right != null) {
        stack1.push(top.right);
      }
    }
    while (!stack2.isEmpty()) {
      System.out.print(stack2.pop().value + " ");
    }
  }

  // 前序遍历思想：先让根进栈，只要栈不为空，就可以做弹出操作，每次弹出一个结点，
  // 记得把它的左右结点都进栈， 记得右子树先进栈，这样可以保证右子树在栈中总处于左子树的下面。
  public static void preOrder(TreeNode root) {
    LinkedList<TreeNode> myStack = new LinkedList<>();
    if (root != null) {
      myStack.push(root);
    }
    while (!myStack.isEmpty()) {
      TreeNode top = myStack.pop();
      System.out.print(top.value + " ");
      if (top.right != null) {
        myStack.push(top.right);
      }
      if (top.left != null) {
        myStack.push(top.left);
      }
    }
  }

  public static void preOrder2(TreeNode root) {
    LinkedList<TreeNode> myStack = new LinkedList<>();
    TreeNode cur = root;
    while (cur != null || !myStack.isEmpty()) {
      while (cur != null) {
        System.out.print(cur.value + " ");
        myStack.push(cur);
        cur = cur.left;
      }
      if (!myStack.isEmpty()) {
        cur = myStack.peekFirst();
        myStack.pop();
        cur = cur.right;
      }
    }
  }

  public static void inOrder(TreeNode root) {
    LinkedList<TreeNode> myStack = new LinkedList<>();
    if (root == null) {
      return;
    }
    TreeNode cur = root;
    while (cur != null || !myStack.isEmpty()) {
      while (cur != null) {
        myStack.push(cur);
        cur = cur.left;
      }
      cur = myStack.pop();
      System.out.print(cur.value + " ");
      cur = cur.right;
    }
  }

  public static void main(String[] args) {

    TreeNode root = new TreeNode();
    root.value = 1;
    createTree(root);
    System.out.print("后序遍历（递归）:");
    postOrderRecursive(root);
    System.out.println();
    System.out.print("后序遍历（非递归）:");
    postOrder(root);
    System.out.println();
    System.out.print("后序遍历（非递归双栈）:");
    postOrder2Stack(root);
    System.out.println();
    System.out.print("先序遍历（非递归）：");
    preOrder2(root);
    System.out.println();
    System.out.print("先序遍历（非递归）：");
    preOrder(root);
    System.out.println();
    System.out.print("中序遍历（非递归）：");
    inOrder(root);
  }

}