## Title Description

Order to achieve the first binary tree, in sequence, after traversal, comprising recursively and non-recursively

## achieve

### Recursively

```
public static class Node {
int val;
Node left;
Node right;
public Node(int data) {
this.val = data;
}
}
// 前序递归
public static void preTraversal(Node head) {
if (head == null) return;
System.out.print(head.val + " ");
preTraversal(head.left);
preTraversal(head.right);
}
// 中序递归
public static void inTraversal(Node head) {
if (head == null) return;
inTraversal(head.left);
System.out.print(head.val + " ");
inTraversal(head.right);
}
// 后序递归
public static void posTraversal(Node head) {
if (head == null) return;
posTraversal(head.left);
posTraversal(head.right);
System.out.print(head.val + " ");
}
```

### A non-recursively

#### prologue

Use the stack structure to achieve, attention to be pressed push the right child, the right child after such a stack order.

```
// 前序非递归
public static void preTravelsal1(Node head) {
if (head == null) return;
Stack<Node> stack = new Stack<>();
stack.push(head);
while (!stack.isEmpty()) {
head = stack.pop();
System.out.print(head.val + " ");
if (head.right != null) stack.push(head.right);
if (head.left != null) stack.push(head.left);
}
}
```

#### In order

It is implemented using a stack structure.

- The current node is not empty, pushed onto the stack, the current node is left child
- The current node is empty, a take from the stack, the current node is the right child

```
// 中序非递归
public static void inTravelsal1(Node head) {
if (head == null) return;
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.val + " ");
head = head.right;
}
}
}
```

#### After the order

Preorder traversal around the root, root around postorder traversal.

So in a non-recursive version it is very easy to order around the root, root into the left and right order. Then place each time before a preorder traversal of the print output, the current to the second node into the stack: the root right and left.

Finally, the data of the second stack to a pop-up time, which is about the order of the root

```
// 后序非递归
public static void posTravelsal(Node head){
if(head == null) return;
Stack<Node> s1 = new Stack<>();
Stack<Node> s2 = new Stack<>();
s1.push(head);
while(!s1.isEmpty()){
head = s1.pop();
s2.push(head);
if(head.left != null) s1.push(head.left);
if(head.right != null) s2.push(head.right);
}
while(!s2.isEmpty()){
System.out.print(s2.pop().val + " ");
}
}
```