public class BinaryTreeNonRecursion {
public static void main(String[] args) {
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);
root.left.right.left = new Node(8);
root.left.right.right = new Node(9);
postOrder(root);
}
/**
* 后序遍历，左子树 -> 右子树 -> 根节点
* 后序遍历的顺序倒过来就是 根节点-> 右子树 -> 左子树
* 在先序遍历的顺序是根节点 -> 左子树 -> 右子树 ，
* 先序遍历是先压根节点 再压右子树，最后压左子树，把压左子树和右子树的顺序换一下，那打印的顺序就是根节点-> 右子树 -> 左子树，我用一个栈先保存，最后出栈时打印就是后序遍历了
*
*/
public static void postOrder(Node root) {
Stack<Node> stack = new Stack<Node>();
Stack<Node> stackPop = new Stack<Node>();
stack.push(root);
while(!stack.isEmpty()) {
Node node = stack.pop();
if(node != null) {
stackPop.push(node);
if(node.left != null) {
stack.push(node.left);
}
if(node.right != null) {
stack.push(node.right);
}
}
}
while(!stackPop.isEmpty()) {
System.out.print(stackPop.pop().value+ " ");
}
}
/**
* 中序遍历， 左子树 -> 根节点 -> 右子树
* @param root
*/
public static void inOrder(Node root) {
Stack<Node> stack = new Stack<Node>();
//从根节点开始，根节点的左节点，左节点的左节点依次入栈
stack.push(root);
while(root.left != null) {
stack.push(root.left);
root= root.left;
}
while(!stack.isEmpty()) {
Node temp = stack.pop();
if(temp != null) {
//栈顶元素出栈，打印该元素，
System.out.print(temp.value + " ");
//右子树不为空，右节点入栈
if(temp.right != null) {
Node n1 = temp.right;
//右节点入栈
stack.push(temp.right);
//右节点的左节点，左节点的左节点入栈
while(n1.left != null) {
stack.push(n1.left);
n1 = n1.left;
}
}
}
}
}
/**
* 先序遍历 根节点 -> 左子树 -> 右子树
* @param root
*/
public static void preOrder(Node root) {
//null可以进入栈里，并且没有限制
Stack<Node> stack = new Stack<Node>();
//根节点入栈
stack.push(root);
while(!stack.isEmpty()) {
//栈顶元素出栈，打印该元素，
Node temp = stack.pop();
if(temp != null) {
System.out.print(temp.value +" ");
//右节点入栈
if(temp.right != null) {
stack.push(temp.right);
}
//左节点入栈
if(temp.left != null) {
stack.push(temp.left);
}
}
}
}
public static class Node {
Node left;
Node right;
int value;
public Node(int value) {
this.value = value;
}
}
}
