java实现二叉树的先序遍历，中序遍历，后序遍历

//二叉树的节点结构
class TreeNode {
int Id=0;
String data=null;
boolean isVisted=false;
TreeNode leftChild=null;
TreeNode rightChild=null;
public TreeNode(){}
public TreeNode(int Id,String data){
this.Id=Id;
this.data=data;
this.leftChild=null;
this.rightChild=null;
}
}

import java.util.Stack;

public class firstBinaryTree {

private TreeNode root=null;
//构造方法
public firstBinaryTree(){
root=new TreeNode(1,"rootNode");
}

//创建二叉树
protected void createBT(TreeNode root){
TreeNode NodeB= new TreeNode(2,"B");
TreeNode NodeC= new TreeNode(3,"C");
TreeNode NodeD= new TreeNode(4,"D");
TreeNode NodeE= new TreeNode(5,"E");
TreeNode NodeF= new TreeNode(6,"F");
TreeNode NodeG= new TreeNode(7,"G");
TreeNode NodeH= new TreeNode(8,"H");
TreeNode NodeI= new TreeNode(9,"I");
root.leftChild=NodeB;
root.rightChild=NodeC;
NodeB.leftChild=NodeD;
NodeB.rightChild=NodeE;
NodeC.leftChild=NodeF;
NodeC.rightChild=NodeG;
NodeD.leftChild=NodeH;
NodeE.rightChild=NodeI;
}

//判断为空
public boolean isEmpty(){
return root==null;
}
//前序非递归遍历
private void preOrederNotR(TreeNode p){
Stack<TreeNode> stack = new Stack<TreeNode>();
TreeNode node=p;
while(node!=null || stack.size()>0){
while(node!=null){
visted(node);
stack.push(node);
node=node.leftChild;
}
if(stack.size()>0){
node=stack.peek();
node=node.rightChild;
stack.pop();
}
}
}

//中序非递归遍历
private void inOrederNotR(TreeNode p){
Stack<TreeNode> stack = new Stack<TreeNode>();
TreeNode node=p;
while(node!=null || stack.size()>0){
while(node!=null){
stack.push(node);
node=node.leftChild;
}
if(stack.size()>0){
node=stack.pop();
visted(node);
node=node.rightChild;
}
}
}

//后序非递归遍历
private void lastOrederNotR(TreeNode p){
Stack<TreeNode> stack = new Stack<TreeNode>();
TreeNode node=p;
while(p!=null){
//左子树入栈
while(p.leftChild!=null){
stack.push(p);
p=p.leftChild;
}
//当前结点无右子树或右子树已经输出
while(p.rightChild==null||p.rightChild==node){
visted(p);
node =p;  //记录上一个已输出结点
if(stack.empty())
return;
p=stack.pop();
}
//右子树进栈
stack.push(p);
p=p.rightChild;
}
}

//前序遍历
private void preOrder(TreeNode subTree) {
// TODO Auto-generated method stub

if(subTree!=null){
visted(subTree);
preOrder(subTree.leftChild);
preOrder(subTree.rightChild);
}
}
//中序遍历
private void inOrder(TreeNode subTree) {
// TODO Auto-generated method stub

if(subTree!=null){
inOrder(subTree.leftChild);
visted(subTree);
inOrder(subTree.rightChild);
}
}
//后序遍历
private void lastOrder(TreeNode subTree) {
// TODO Auto-generated method stub

if(subTree!=null){
lastOrder(subTree.leftChild);
lastOrder(subTree.rightChild);
visted(subTree);
}
}

//访问该节点
private void visted(TreeNode subTree) {
// TODO Auto-generated method stub
subTree.isVisted=true;
System.out.println("ID:"+subTree.Id+"name:"+subTree.data);
}

public static void main(String[] args) {
// TODO Auto-generated method stub

firstBinaryTree bt= new firstBinaryTree();
bt.createBT(bt.root);
bt.preOrder(bt.root);
bt.preOrederNotR(bt.root);
System.out.println("------------------------------");
bt.inOrder(bt.root);
bt.inOrederNotR(bt.root);
System.out.println("--------------------------------");
bt.lastOrder(bt.root);
bt.lastOrederNotR(bt.root);

}

}