java实现树的前序，中序，后序的递归和非递归遍历

package edu.hue.jk.tree;
import java.util.Stack;
class Person implements Comparable<Person>{
	int age;
	String name;
	@Override
	public int compareTo(Person o) {
		if(this.age>o.age)
			return 1;
		return 0;
	}
	Person(){}
	Person(int age,String name){
		this.age=age;
		this.name=name;
		
	}
	@Override
	public String toString() {
		return "age:"+this.age+"   name:"+this.name;
	}
}
//定义数的结构
class MyTree<T>{
	T data;
	MyTree<T> lchild;  //左子树
  	MyTree<T> rchild;  //右子树
  	MyTree(T data){
  		this.data=data;
  		this.lchild=null;
  		this.rchild=null;
  	}
  	
	//插入结点，建立二叉排序树
  	void insertNode(T node){
  		MyTree<T> currentNode=this;
  		MyTree<T> parentNode=this;
  		while(currentNode!=null){
  			parentNode=currentNode;
  			if(node.getClass()==Integer.class){
	  			if((Integer)(currentNode.data)>(Integer)node){
	  				currentNode=currentNode.lchild;
	  			}
	  			else{
	  				currentNode=currentNode.rchild;
	  			}
  			}
  			if(node.getClass()==Float.class){
  				if((Float)(currentNode.data)>(Float)node){
  					currentNode=currentNode.lchild;
  				}
  				else{
  					currentNode=currentNode.rchild;
  				}
  			}
  			if(node.getClass()==Person.class){
  				if((((Person)currentNode.data).compareTo((Person)node))>0){
  					currentNode=currentNode.lchild;
  				}
  				else{
  					currentNode=currentNode.rchild;
  				}
  			}
  		}
  		if(node.getClass()==Integer.class){
	  		MyTree<T> newNode=new MyTree<T>(node);
	  		if((Integer)(parentNode.data)>(Integer)node){
	  			parentNode.lchild=newNode;
	  		}
			else{
				parentNode.rchild=newNode;
			}
  		}
  		if(node.getClass()==Float.class){
  			MyTree<T> newNode=new MyTree<T>(node);
  			if((Float)(parentNode.data)>(Float)node){
  				parentNode.lchild=newNode;
  			}
  			else{
  				parentNode.rchild=newNode;
  			}
  		}
  		if(node.getClass()==Person.class){
  			MyTree<T> newNode=new MyTree<T>(node);
  			if((((Person)(parentNode.data)).compareTo((Person)node))>0){
  				parentNode.lchild=newNode;
  			}
  			else{
  				parentNode.rchild=newNode;
  			}
  		}
  	}
  	// 先序遍历二叉树
  	void preSearch(MyTree<T> pp){
  		if(pp!=null){
  			System.out.print(pp.data+" ");
  			preSearch(pp.lchild);
  			preSearch(pp.rchild);
  		}
  	}
  
  	//先序遍历非递归写法
  	void preSearchf(MyTree<T> pp){
  		Stack<MyTree<T>> stack=new Stack<MyTree<T>>();  //定义一个栈
  		MyTree<T> p=pp;
  		while(!(p==null && stack.empty())){  //当且仅当当前结点为空且队列为空时，遍历完成
  			if(p!=null){
  				System.out.print(p.data+" ");
  				if(p.rchild!=null)
  					stack.add(p);  //如果右结点不为空就入栈
  				p=p.lchild;  //遍历左子树
  			}
  			else{
  				p=stack.lastElement().rchild;  //取栈顶元素的又子树
  				stack.pop(); //出栈
  			}
  		}
  	}
  	
  	//中序递归遍历二叉树
  	void orderSearch(MyTree<T> pp){
  		if(pp!=null){
  			orderSearch(pp.lchild);
  			System.out.print(pp.data+" ");
  			orderSearch(pp.rchild);
  		}
  	}
  	
  	//中序非递归遍历二叉树
  	void orderSearchf(MyTree<T> pp){
  		Stack<MyTree<T>> stack=new Stack<MyTree<T>>();
  		MyTree<T> p=pp;
  		while(!(p==null && stack.empty())){
  			if(p!=null){
  				stack.add(p);
  				p=p.lchild;
  			}
  			else{
  				p=stack.lastElement();
  				stack.pop();
  				System.out.print(p.data+" ");
  				p=p.rchild;
  			}
  		}
  	}
  	//后序递归遍历二叉树
  	void postSearch(MyTree<T> p){
  		if(p!=null){
  			postSearch(p.lchild);
  			postSearch(p.rchild);
  			System.out.print(p.data+" ");
  		}
  	}
  	//后序非递归遍历二叉树
  	void postSearchf(){
  		MyTree<T> p=this;
  		MyTree<T> pre=null;
  		Stack<MyTree<T>> stack=new Stack<MyTree<T>>();
  		while(!(stack.empty()&&p==null)){
  			if(p!=null){
  				stack.push(p);
  				p=p.lchild;
  			}
  			else{
  				p=stack.lastElement();   //取栈顶元素,先不出栈
  				if(p.rchild!=null && p.rchild!=pre){
  					pre=p;
  					p=p.rchild;
  				}
  				else{
  					System.out.print(p.data+" ");
  					stack.pop();  //访问根元素之后再出栈
  					pre=p;
  					p=null;
  				}
  			}
  		}
  	}
  	
};
public class TheTree {
	public static void main(String[] args) {
		MyTree<Integer> int_tree=new MyTree<Integer>(70);
		
		int_tree.insertNode(60);
		int_tree.insertNode(80);
		int_tree.insertNode(55);
		int_tree.insertNode(65);
		int_tree.insertNode(78);
		System.out.println("*******************先序遍历结果：************");
		int_tree.preSearch(int_tree);
		System.out.println();
		int_tree.preSearchf(int_tree);
		System.out.println();
		System.out.println("*******************先序遍历结束：************");
		System.out.println();
		System.out.println("*******************中序遍历结果：************");
		System.out.println();
		int_tree.orderSearch(int_tree);
		System.out.println();
		int_tree.orderSearchf(int_tree);
		System.out.println();
		System.out.println("*******************后序遍历结束：************");
		System.out.println();
		int_tree.postSearch(int_tree);
		System.out.println();
		int_tree.postSearchf();
		System.out.println();
		System.out.println("*******************后序遍历结束：************");
		
		
		MyTree<Float> float_tree=new MyTree<Float>(70.0f);
		float_tree.insertNode(60.0f);
		float_tree.insertNode(80.0f);
		float_tree.insertNode(50.0f);
		float_tree.insertNode(48.0f);
		float_tree.insertNode(35.0f);
		float_tree.insertNode(49.0f);
		float_tree.insertNode(75.0f);
		System.out.println("*******************先序遍历结果：************");
		float_tree.preSearch(float_tree);
		System.out.println();
		float_tree.preSearchf(float_tree);
		System.out.println();
		System.out.println("*******************先序遍历结束：************");
		System.out.println();
		System.out.println("*******************中序遍历结果：************");
		System.out.println();
		float_tree.orderSearch(float_tree);
		System.out.println();
		float_tree.orderSearchf(float_tree);
		System.out.println();
		System.out.println("*******************后序遍历结束：************");
		System.out.println();
		float_tree.postSearch(float_tree);
		System.out.println();
		float_tree.postSearchf();
		System.out.println();
		System.out.println("*******************后序遍历结束：************");
		
		
		MyTree<Person>person_tree=new MyTree<Person>(new Person(70,"123"));
		person_tree.insertNode(new Person(60,"456"));
		person_tree.insertNode(new Person(50,"456"));
		System.out.println("*******************先序遍历结果：************");
		person_tree.preSearch(person_tree);
		System.out.println();
		person_tree.preSearchf(person_tree);
		System.out.println();
		System.out.println("*******************先序遍历结束：************");
		System.out.println();
		System.out.println("*******************中序遍历结果：************");
		System.out.println();
		person_tree.orderSearch(person_tree);
		System.out.println();
		person_tree.orderSearchf(person_tree);
		System.out.println();
		System.out.println("*******************后序遍历结束：************");
		System.out.println();
		person_tree.postSearch(person_tree);
		System.out.println();
		person_tree.postSearchf();
		System.out.println();
		System.out.println("*******************后序遍历结束：************");
	}

}