二叉树先序、中序，后序遍历的非递归实现

public static class Node {
public int value;
public Node left;
public Node right;

public Node(int data) {
this.value = data;
}
}

先序

根--左---右
使用栈，先装下根节点（头节点），出栈并输出，并且把出栈的节点的 右节点---左节点，依次入栈。循环public static void preOrderUnRecur(Node head){
Stack<Node> stack = new Stack<Node>();
if(head!=null){
System.out.print("pre-order: ");
stack.add(head);
while(!stack.isEmpty()){
head = stack.pop();
System.out.print(head.value+" ");
if(head.right!=null){
stack.add(head.right);
}
if(head.left!=null){
stack.add(head.left);
}
}
System.out.println();
}
}

中序

左--根---右
依旧使用栈
中序遍历是先打印左节点
                    5

                2

             1

          3
这是一颗只有左节点的二叉树
先序应该先左节点，再中节点，再右节点。只有有一个节点有左节点，那么依次装入栈中出栈时去看看，右边节点有没有了，
有的话依旧，装完他的左节点，然后，出栈（加打印）public static void inOrderUnRecur(Node head){
if(head!=null){
System.out.print("in-order: ");
Stack<Node> stack = new Stack<Node>();
while(!stack.isEmpty()||head!=null){

while(head!=null){
stack.add(head);
head = head.left;
}

head= stack.pop();
System.out.print(head.value+" ");
head = head.right;

}
System.out.println();
}
}

后序

左--右--根
后序遍历有好几种做法，这里介绍最简单的一种
刚刚介绍了前序遍历，他的原理是直接输入跟节点，然后装入栈中 右节点，再装入左节点，再输入，根据栈的先进后出
那么应该左节点先出来，遍历完左节点再去遍历右节点。
我们的后序遍历。使用原来的前序遍历，但是并不输出节点，而是装入B栈中。
按原来的模式，
根节点装入B栈。（这里不输出了而是装入另一个栈中）
但是这里应该先左节点进A栈，
右节点再装入A栈，

这样一来装二叉树的B栈装入顺序应该是
根--右---左（看代码理解，我讲述的可能不是太清楚）
那么直接让他们出栈，
即是左---右---根public static void inOrderUnRecur(Node head){
if(head!=null){
System.out.print("in-order: ");
Stack<Node> stack = new Stack<Node>();
while(!stack.isEmpty()||head!=null){

while(head!=null){
stack.add(head);
head = head.left;
}

head= stack.pop();
System.out.print(head.value+" ");
head = head.right;

}
System.out.println();
}
}

全部代码，，，附加一颗这样的二叉树

                                5
                      3                    8

                  2    4                7    10

               1                        6

没有连线，单应该能看懂。package basic_class_04;
import java.util.*;

public class Main {

public static class Node { public int value; public Node left; public Node right; public Node(int data) { this.value = data; } }
public static void preOrderUnRecur(Node head){
Stack<Node> stack = new Stack<Node>();
if(head!=null){
System.out.print("pre-order: ");
stack.add(head);
while(!stack.isEmpty()){
head = stack.pop();
System.out.print(head.value+" ");
if(head.right!=null){
stack.add(head.right);
}
if(head.left!=null){
stack.add(head.left);
}
}
System.out.println();
}
}
public static void inOrderUnRecur(Node head){
if(head!=null){
System.out.print("in-order: ");
Stack<Node> stack = new Stack<Node>();
while(!stack.isEmpty()||head!=null){

while(head!=null){
stack.add(head);
head = head.left;
}

head= stack.pop();
System.out.print(head.value+" ");
head = head.right;

}
System.out.println();
}
}
public static void posOrderUnRecur(Node head){
Stack<Node> stack = new Stack<Node>();
Stack<Node> stack2 = new Stack<Node>();
if(head!=null){
System.out.print("pre-order: ");
stack.add(head);
while(!stack.isEmpty()){
head = stack.pop();
stack2.add(head);
if(head.left!=null){
stack.add(head.left);
}
if(head.right!=null){
stack.add(head.right);
}
}
while(!stack2.isEmpty()){
System.out.print(stack2.pop().value+" ");
}
System.out.println();
}
}

public static void main(String[] args){
Node head = new Node(5);
head.left = new Node(3);
head.right = new Node(8);
head.left.left = new Node(2);
head.left.right = new Node(4);
head.left.left.left = new Node(1);
head.right.left = new Node(7);
head.right.left.left = new Node(6);
head.right.right = new Node(10);
head.right.right.left = new Node(9);
head.right.right.right = new Node(11);

//----------先序------------//
preOrderUnRecur(head);
//----------中序------------//
inOrderUnRecur(head);
//----------后序------------//
posOrderUnRecur(head);
}

}