实现二叉树的遍历（递归与非递归）

二叉树如下：

创建一个节点类Node
定义一个整形data成员变量
一个Node类型左节点
一个Node类型右节点

public class Node {
     public int data;
     public Node leftNode;
     public Node rightNode;
     }

添加节点方法addNode()

 //添加节点     
     public void  addNode(Node t) {
    	 if(t.data<this.data) {
    		if(this.leftNode==null)
    			leftNode=t;
    		else
    		  leftNode.addNode(t);
    	 }else  {
    		 if(rightNode==null)
    			 rightNode=t;
    		 else 
    			 rightNode.addNode(t);
    	 }	
     }

先序递归与非递归
思路：访问根节点->先序遍历左子树->先序遍历右子树

 //先序   递归
     public void xianxu() {
    	 System.out.print(data+" ");
    	 if(leftNode!=null)  leftNode.xianxu();	
    	 if(rightNode!=null) rightNode.xianxu();
     }

 //先序非递归
public void preOrder(Node t) {
	if(t==null) {
		System.out.println("空树");
		return;
	}
	Node tmp=t;
	Stack<Node> s=new Stack<Node>();
	s.push(tmp);  //根节点入栈
	while(!s.empty()) {
		//1.访问根节点
		Node p=s.pop();
		System.out.print(p.data+" ");
		//2.如果根节点存在右孩子，则将右孩子入栈
		if(p.rightNode!=null) {
			s.push(p.rightNode);
		}
		//3.如果根节点存在左孩子，则将左孩子入栈
		if(p.leftNode!=null) {
			s.push(p.leftNode);
		}
	}
}

中序递归与非递归
思路：中序遍历左子树->访问根节点->中序遍历右子树

//中序    递归
     public void zhongxu() {
    	 if(leftNode!=null)  leftNode.zhongxu();
    	 System.out.print(data+" ");
    	 if(rightNode!=null) rightNode.zhongxu();
     } 

//非递归中序
public void inOrder(Node t) {
	if(t==null) {
		System.out.println("空树");
		return;
	}
	Node tmp=t;
	Stack<Node> s=new Stack<Node>();
	while(tmp!=null || !s.empty()) {
		//1.将根节点入栈
		//2.将所有左孩子入栈
		while(tmp!=null) {
			s.push(tmp);
			tmp=tmp.leftNode;
		}
		//3.访问栈顶元素
		tmp=s.pop();
		System.out.print(tmp.data+" ");
		//4.如果栈顶元素存在右孩子，则将右孩子赋值给tmp，也就是将右孩子入栈
		if(tmp.rightNode!=null) {
			tmp=tmp.rightNode;
		}
		//否则，将tmp置为null，表示下次要访问的是栈顶元素
		else {
			tmp=null;
		}
	}
}

后序递归与非递归
思路：后序遍历左子树->后序遍历右子树->访问根节点

//后序     递归
     public void houxu() {
    	 if(leftNode!=null)  leftNode.houxu();
    	 if(rightNode!=null) rightNode.houxu();
    	 System.out.print(data+" ");
     }

//非递归后序
	public void postOrder(Node t) {
		if(t==null) {
			System.out.println("空树");
			return;
		}
		Node tmp=t;  //当前节点
		Node prev=null; //上一次访问的节点
		Stack<Node> s=new Stack<Node>();
		while(tmp!=null || !s.empty()) {
			//1.将根节点及其左孩子入栈
			while(tmp!=null) {
				s.push(tmp);
				tmp=tmp.leftNode;
			}
			
			if(!s.empty()) {
				//2.获取栈顶元素值
				tmp=s.peek();
				//3.没有右孩子，或者右孩子已经被访问过
				if(tmp.rightNode==null || tmp.rightNode==prev) {
					//则可以访问栈顶元素
					tmp=s.pop();
					System.out.print(tmp.data+" ");
					//标记上一次访问的节点
					prev=tmp;
					tmp=null;
				}
				//4.存在没有被访问的右孩子
				else {
					tmp=tmp.rightNode;
				}
			}
		}
	}

创建树类Mytree

public class MyTree {
     private Node root;
     }

添加元素方法add()

public void add(int x) {
    	 Node p=new Node();
    	 p.data=x;
    	 if(root==null)
    		 root=p;
    	 else
    		root.addNode(p);
     }

遍历方法的调用

 public void xx() {
    	 if(root==null) return;
 		    root.xianxu();
     }
     
     public void zx() {
    	 if(root==null) return;
    		root.zhongxu();
     }
     public void hx() {
    	 if(root==null) return;
    		root.houxu();
     }
     
     public void xx1() {
    	 if(root==null) return;
 		    root.preOrder(root);
     }
     
     public void zx1() {
    	 if(root==null) return;
    		root.inOrder(root);
     }
     public void hx1() {
    	 if(root==null) return;
    		root.postOrder(root);
     }

测试

 public static void main(String[] args) {
    	 MyTree my =new MyTree();
    	 my.add(7);
    	 my.add(2);
    	 my.add(5);
    	 my.add(9);
    	 my.add(4);
    	 my.add(0);
    	 my.add(10);
    	 my.add(56);
    	 System.out.print("递归先序为：");
    	 my.xx();//先序
    	 System.out.println();
    	 System.out.print("中序递归为：");
    	 my.zx();//中序
    	 System.out.println();
    	 System.out.print("递归后序为：");
    	 my.hx();//后序
    	 System.out.println();
    	 System.out.print("非递归先序为：");
    	 my.xx1();//先序
    	 System.out.println();
    	 System.out.print("非中序递归为：");
    	 my.zx1();//中序
    	 System.out.println();
    	 System.out.print("非递归后序为：");
    	 my.hx1();//后序
    	
    	 
     }

结果

递归先序为：7 2 0 5 4 9 10 56
中序递归为：0 2 4 5 7 9 10 56
递归后序为：0 4 5 2 56 10 9 7
非递归先序为：7 2 0 5 4 9 10 56
非中序递归为：0 2 4 5 7 9 10 56
非递归后序为：0 4 5 2 56 10 9 7