二叉树的先序、中序、后序、层次遍历的递归和非递归解法

package tree;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class TreeTraverse {
	/**
	 * 先序递归
	 * @param root
	 */
	public static void preOrderTraverse(TreeNode root) {
		if (root == null) {
			return;
		}

		System.out.print(root.val + " ");
		preOrderTraverse(root.left);
		preOrderTraverse(root.right);
	}

	/**
	 * 先序非递归
	 * @param root
	 */
	public static void preOrderTraverseNoR(TreeNode root) {
		if (root == null) {
			return;
		}

		Stack<TreeNode> st = new Stack<TreeNode>();
		TreeNode pNode = root;

		while (pNode != null || !st.isEmpty()) {
			if (pNode != null) {
				System.out.print(pNode.val + " ");
				st.push(pNode);
				pNode = pNode.left;
			} else {
				pNode = st.pop();
				pNode = pNode.right;
			}
		}
	}

	/**
	 * 中序递归
	 * @param root
	 */
	public static void inOrderTraverse(TreeNode root) {
		if (root == null) {
			return;
		}

		inOrderTraverse(root.left);
		System.out.print(root.val + " ");
		inOrderTraverse(root.right);
	}

	/**
	 * 中序非递归
	 * @param root
	 */
	public static void inOrderTraverseNoR(TreeNode root) {
		if (root == null) {
			return;
		}

		Stack<TreeNode> st = new Stack<TreeNode>();
		TreeNode pNode = root;

		while (pNode != null || !st.isEmpty()) {
			if (pNode != null) {
				st.push(pNode);
				pNode = pNode.left;
			} else {
				pNode = st.pop();
				System.out.print(pNode.val + " ");
				pNode = pNode.right;
			}
		}
	}

	/**
	 * 中序递归
	 * @param root
	 */
	public static void postOrderTraverse(TreeNode root) {
		if (root == null) {
			return;
		}

		postOrderTraverse(root.left);
		postOrderTraverse(root.right);
		System.out.print(root.val + " ");
	}

	/**
	 * 后序非递归
	 * @param root
	 */
	public static void postOrderTraverseNoR(TreeNode root) {
		if (root == null) {
			return;
		}

		Stack<TreeNode> st = new Stack<TreeNode>();
		st.push(root);
		TreeNode pNode = null;
		TreeNode preNode = null;
		while (!st.isEmpty()) {
			pNode = st.peek();
			// 如果当前节点没有子结点或者子结点被访问过
			if ((pNode.left == null && pNode.right == null) || (preNode != null && (pNode.left == preNode || pNode.right == preNode))) {
				System.out.print(pNode.val + " ");
				preNode = st.pop();
			} else {
				if (pNode.right != null) {
					st.push(pNode.right);
				} 

				if (pNode.left != null) {
					st.push(pNode.left);
				}
			}
		}
	}

	/**
	 * 层次遍历
	 * @param root
	 */
	public static void levelOrderTraverse(TreeNode root) {
		if (root == null) {
			return;
		}

		Queue<TreeNode> q = new LinkedList<TreeNode>();
		q.offer(root);
		TreeNode pNode = null;
		while (!q.isEmpty()) {
			pNode = q.poll();
			System.out.print(pNode.val + " ");
			if (pNode.left != null) {
				q.offer(pNode.left);
			}
			if (pNode.right != null) {
				q.offer(pNode.right);
			}
		}
	}

	public static void main(String[] args) {
		TreeNode node0 = new TreeNode(0);
		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);
		TreeNode node8 = new TreeNode(8);
		node1.left = node0;
		node4.left = node2;
		node4.right = node6;
		node2.left = node1;
		node2.right = node3;
		node6.left = node5;
		node6.right = node7;
		node7.right = node8;

		preOrderTraverse(node4);
		System.out.println();
		preOrderTraverseNoR(node4);
		System.out.println();
		inOrderTraverse(node4);
		System.out.println();
		inOrderTraverseNoR(node4);
		System.out.println();
		postOrderTraverse(node4);
		System.out.println();
		postOrderTraverseNoR(node4);
		System.out.println();
		levelOrderTraverse(node4);
	}
}