题目：
用递归和非递归方式，分别按照二叉树先序、中序和后续打印所有的节点。先序为根左右，中序为左根右，后序为左右根。
递归方式：
（1）先序：
//先序 根左右
public static void preOrderRecur(Node head) {
if (head == null) {
return;
}
System.out.println(head.value + " ");
preOrderRecur(head.left);
preOrderRecur(head.right);
}（2）中序：
//中序 左根右
public static void inOrderRecur(Node head) {
if (head == null) {
return;
}
inOrderRecur(head.left);
System.out.print(head.value + " ");
inOrderRecur(head.right);
}（3）后序：
//后序 左右根
public static void postOrderRecur(Node head) {
if (head == null) {
return;
}
postOrderRecur(head.left);
postOrderRecur(head.right);
System.out.print(head.value + " ");
}测试结果：
public static void main(String[] args) {
Node head = new Node(1);
Node node1 = new Node(2);
Node node2 = new Node(3);
Node node3 = new Node(4);
Node node4 = new Node(5);
Node node5 = new Node(6);
head.left = node1;
head.right = node2;
node1.left = node3;
node1.right = node4;
node2.right = node5;
preOrderRecur(head);
System.out.println();
inOrderRecur(head);
System.out.println();
postOrderRecur(head);
}结果：
非递归方式：
（1）先序：
具体过程如下：
（1）申请一个新的栈，记为stack，然后将头节点head压入栈中。
（2）从stack中弹出栈顶节点，记为cur，然后打印cur节点的值，再将节点cur的右孩子（不为空）入栈，最后将cur的左孩子（不为空的话）入栈。
（3）不断重复（2）过程，直到stack为空。
代码实现：
//非递归先序
public static void preOrderUnRecur(Node head) {
System.out.print("非递归先序：");
if (head != null) {
Stack<Node> stack = new Stack<>();
stack.add(head);
while (!stack.isEmpty()) {
head = stack.pop();
System.out.print(head.value + " ");
if (head.right != null) {
stack.push(head.right);
}
if (head.left != null) {
stack.push(head.left);
}
}
}
}（2）中序：
具体过程如下：
（1）申请一个新的栈，记为stack，初始时，令变量cur=head。
（2）先把cur节点压入栈，对以cur节点为头节点的整颗子树来说，依次把左边界压入栈中，即不停的令 cur = cur.left，然后重复步骤（2）。
（3）不断重复步骤2，直到发现cur为空，此时从 stack 中弹出一个节点，记为 node，打印node的值，并且让 cur = node.right，（这里注意，让cur=node.right的时候，cur的值已经打印了，也就是根的值已经打印了，所以可以保证根在右前面打印）然后继续重复步骤2。
（4）当stack为空且cur为空时，整个过程停止。
代码实现：
//非递归中序
public static void inOrderUnRecur(Node head) {
System.out.print("非递归中序：");
if(head != null) {
Stack<Node> stack = new Stack<>();
while (!stack.isEmpty() || head != null) {
//先把左子树都放进栈
if (head != null) {
stack.push(head);
head = head.left;
} else {
head = stack.pop();
System.out.print(head.value + " ");
head = head.right;
}
}
}
}（3）后序：
具体过程：
（1）申请一个栈记为 stack1，然后将头节点head压入stack1中。
（2）从stack1中弹出的节点记为cur，然后依次将cur的左孩子节点和右孩子节点压入stack1中。（先左后右）
（3）在整个过程中，每一个从stack1弹出的节点都放入 stack2中。
（4）不断重复（2）（3），直到s1为空，过程停止。
（5）从s2中依次弹出节点并打印，打印的顺序就是后序遍历的顺序。
每颗子树的头节点先从stack1弹出到stack2，然后把它的孩子从左到右压入到stack1，再从stack1中弹出的顺序就是先右再左，从stack1弹出的顺序就是 根 右 左，stack2与stack1相反，所以就是左右根。
代码实现：
//非递归后序
public static void postOrderUnRecur(Node head) {
System.out.print("非递归后序：");
if (head != null) {
Stack<Node> stack1 = new Stack<>();
Stack<Node> stack2 = new Stack<>();
stack1.push(head);
while (!stack1.isEmpty()) {
head = stack1.pop();
stack2.push(head);
if (head.left != null) {
stack1.push(head.left);
}
if (head.right != null) {
stack1.push(head.right);
}
}
while (!stack2.isEmpty()) {
System.out.print(stack2.pop().value + " ");
}
}
}测试结果：
