二叉树的前中后序遍历（递归+非递归）

/**
 * 二叉树节点类
 * @author wj
 *
 */
class TreeNode{
	int value;
	TreeNode left_Node;
	TreeNode right_Node;
	
	public TreeNode(int value) {
		this.value = value;
		this.left_Node = null;
		this.right_Node = null;
	}
}
/**
 * 二叉树类
 * @author wj
 *
 */
class BinaryTree{
	/**
	 * 根结点
	 */
	public TreeNode treeNode;
	/**
	 * 利用传入一个数组的参数来建立二叉树
	 */
	public BinaryTree(int[] data) {
		for(int i = 0;i < data.length;i++) {
			Add_Node_To_Tree(data[i]);
		}
	}
	private void Add_Node_To_Tree(int value) {
		// TODO Auto-generated method stub
		if(treeNode == null) {
			treeNode = new TreeNode(value);
			return;
		}
		/**
		 * 建立二叉树
		 */
		TreeNode currentNode = treeNode;
		while(true) {
			
			if(value < currentNode.value) {//在左子树
				if(currentNode.left_Node == null) {
					currentNode.left_Node = new TreeNode(value);
					return ;
				}else {
					currentNode = currentNode.left_Node;
				}
			}else{
				if(currentNode.right_Node == null) {
					currentNode.right_Node = new TreeNode(value);
					return ;
				}else {
					currentNode = currentNode.right_Node;
				}
			}
		}
	}
	/**
	 * 中序遍历
	 * @param node
	 */
	public static void inOrder(TreeNode node) {
		if(node != null) {
			inOrder(node.left_Node);
			System.out.print("["+node.value+"] ");
			inOrder(node.right_Node);
		}
	}
	
	/**
	 * 前序遍历
	 * @param args
	 */
	public static void perOrder(TreeNode node) {
		if(node != null) {
			System.out.print("["+node.value+"] ");
			perOrder(node.left_Node);
			perOrder(node.right_Node);
		}
	}
	/**
	 * 后序遍历
	 */
	public static void PostOrder(TreeNode node) {
		if(node != null) {
			PostOrder(node.left_Node);
			PostOrder(node.right_Node);
			System.out.print("["+node.value+"] ");
		}
	}
	/**
	 * 非递归先序遍历
	 * @param node
	 */
	public static void newperOrder(TreeNode head) {
		if(head == null) {
			return;
		}
		Stack<TreeNode> stack = new Stack<>();
		stack.add(head);
		while(!stack.empty()){
			head = stack.pop();
			System.out.print(head.value+" ");
			if(head.right_Node != null) {
				stack.add(head.right_Node);
			}
			if(head.left_Node != null) {
				stack.add(head.left_Node);
			}
		}
		
	}
	/**
	 * 非递归中序遍历
	 * @param node
	 */
	public static void newinOrder(TreeNode head) {
		if(head == null) {
			return;
		}
		Stack<TreeNode> stack = new Stack<>();
		while(!stack.empty() || head!= null) {
			if(head != null) {
				stack.add(head);
				head = head.left_Node;
			}else {
				head = stack.pop();
				System.out.print(head.value+" ");
				head = head.right_Node;
			}
			
		}
	}
	/**
	 * 非递归后序遍历
	 * @param node
	 */
	public static void newPostOrder(TreeNode head) {
		if(head == null) {
			return;
		}
		Stack<TreeNode> stack = new Stack<>();
		Stack<TreeNode> stack1 = new Stack<>();
		stack.add(head);
		while(!stack.empty()) {
			head = stack.pop();
			stack1.add(head);
			if(head.left_Node != null) {
				stack.add(head.left_Node);
			}
			if(head.right_Node != null) {
				stack.add(head.right_Node);
			}
		}
		while(!stack1.empty()) {
			System.out.print(stack1.pop().value+" ");
		}
	}
}
public class Test2 {
	public static void main(String[] args) {
		int[] data = {6,3,5,9,7,8,4,2};
		BinaryTree binaryTree = new BinaryTree(data);
		BinaryTree.inOrder(binaryTree.treeNode);
		System.out.println();
		BinaryTree.perOrder(binaryTree.treeNode);
		System.out.println();
		BinaryTree.PostOrder(binaryTree.treeNode);
		System.out.println();
		BinaryTree.newperOrder(binaryTree.treeNode);
		System.out.println();
		BinaryTree.newinOrder(binaryTree.treeNode);
		System.out.println();
		BinaryTree.newPostOrder(binaryTree.treeNode);
	}
}

先序：中 左 右

中序：左 中 右

后序：左 右 中