public class Node { 
Object data; 
Node leftChild; 
Node rightChild; 

public Node() { 
} 

public Node(Object data) { 
leftChild = null; 
rightChild = null; 
this.data = http://www.mamicode.com/data;
} 

public Node(Object data, Node leftChild, Node rightChild) { 
this.data = http://www.mamicode.com/data;
this.leftChild = leftChild; 
this.rightChild = rightChild; 
} 
}

/****************遍历非递归实现********************/ 
/** 
* 非递归实现前序遍历 :根左右 
* <p/> 
* 算法思想：利用一个栈，先序遍历即为根先遍历 
* 这种实现类似于图的深度优先遍历（DFS） 
* 维护一个栈，将根节点入栈，然后只要栈不为空，出栈并访问，接着依次将访问节点的右节点、左节点入栈。 
* 这种方式应该是对先序遍历的一种特殊实现（看上去简单明了），但是不具备很好的扩展性，在中序和后序方式中不适用 
* <p/> 
* 有类似树的结构的遍历的递归转非递归都是由栈来实现，如查找文件夹里的所有文件 
*/ 
public void iterativePreOrder(Node root) { 
System.out.print("\n非递归前序遍历 "); 
Stack<Node> stack = new Stack<Node>(); 
if (root != null) { 
stack.push(root); //入栈 

while (!stack.empty()) { 
root = stack.pop(); //出栈 
System.out.print(root.data + " "); 

if (root.rightChild != null) 
stack.push(root.rightChild); 

if (root.leftChild != null) 
stack.push(root.leftChild); 
} 
} 

} 

/** 
* 非递归中序遍历(左根右) 
* 
* 算法思想和上面的iterativePreOrder相同， 
* 只是访问的时间是在左子树都处理完直到null的时候出栈并访问。 
*/ 
public void iterativeInOrder(Node root) { 
System.out.print("\n非递归中序遍历 "); 
if (root == null) 
return; 
Stack<Node> stack = new Stack<Node>(); 

while (root != null || !stack.isEmpty()) { 
while (root != null) { 
stack.push(root);//先访问再入栈 
root = root.leftChild; 
} 
root = stack.pop(); //出栈 
System.out.print(root.data + ","); 

root = root.rightChild;//如果左子树是null，出栈并处理右子树 
} 

} 

/** 
* 非递归实现后序遍历 
*/ 
public void iterativePostOrder(Node root) { 
System.out.print("\n非递归后序遍历: "); 
Node tempNode = root; 
Stack<Node> stack = new Stack<Node>(); 

while (root != null) { 
//左子树入栈 
for (; root.leftChild != null; root = root.leftChild) 
stack.push(root); 

// 当前节点无右子或右子已经输出 
while (root != null && 
(root.rightChild == null || root.rightChild == tempNode)) { 
System.out.print(root.data + " "); 

tempNode = root; //记录上一个已输出节点 
if (stack.empty()) 
return; 

root = stack.pop(); //出栈 
} 

//处理右子 
stack.push(root); 

assert root != null; 
root = root.rightChild; 
} 
}

* 层序遍历（有点类型先序遍历的非递归） 
* <p/> 
* 算法思想：用队列实现，先将根节点入队列，只要队列不为空， 
* 然后出队列，并访问，接着讲访问节点的左右子树依次入队列 
* 
* @param root 被遍历的二叉树的根节点 
*/ 
public void levelTravel(Node root) { 
if (root == null) 
return; 

Queue<Node> queue = new LinkedList<Node>(); 
queue.add(root); 

while (!queue.isEmpty()) { 
Node temp = queue.poll(); //出列 
System.out.print(temp.data + ","); 

if (temp.leftChild != null) 
queue.add(temp.leftChild); 

if (temp.rightChild != null) 
queue.add(temp.rightChild); 
} 
}