java创建二叉树并遍历

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/benzhaohao/article/details/78465073

java在实现非递归先根，中根，后根遍历时需要用到链栈Linkstack类，实现非递归层次遍历需要用到链队列Linkqueue类，前面文章已经实现。

下面实现二叉链式存储结构

package practice3;
public class bitreeNode {
	private Object data;  //结点的数据域
	private bitreeNode lchild,rchild; //左右孩子域
	public bitreeNode(){    //构造空结点
		this(null,null,null);
	}
	public bitreeNode(Object data){  //构造一棵左右孩子域为空的二叉树 
		this(data,null,null);
	}
	public bitreeNode(Object data,bitreeNode lchild,bitreeNode rchild){ //构造一棵数据域和左右孩子域都不为空的二叉树
		this.data=data;
		this.lchild=lchild;
		this.rchild=rchild;
	}
	public Object getdata(){
		return data;
	}
	public bitreeNode getlchild(){
		return lchild;
	}
	public bitreeNode getrchild(){
		return rchild;
	}
	public void setdata(Object data){
		this.data=data;
	}
	public void setlchild(bitreeNode lchild){
		this.lchild=lchild;
	}
	public void setrchild(bitreeNode rchild){
		this.rchild=rchild;
	}
}

实现递归与非递归遍历

package practice3;

public class bitree {
	public bitreeNode root;   //树的根节点
	public bitree(){    //构造一棵空树
		this.root=null;
	}
	public bitree(bitreeNode root){ //构造一棵树
		this.root=root;
	}
	public void preroottraverse(bitreeNode t){  //递归先根遍历
		if(t!=null){
			System.out.print(t.getdata());   //访问根节点
			preroottraverse(t.getlchild());  //先根遍历左子树
			preroottraverse(t.getrchild());  //先根遍历右子树
		}
	}
	public void inroottraverse(bitreeNode t){   //递归中根遍历
		if(t!=null){ 
			inroottraverse(t.getlchild());   //中根遍历左子树
			System.out.print(t.getdata());   //访问根节点
			inroottraverse(t.getrchild());  //中根遍历右子树
		}
	}
	public void postroottraverse(bitreeNode t){    //递归后根遍历
		if(t!=null){
			postroottraverse(t.getlchild());  //后根遍历左子树
			postroottraverse(t.getrchild());   //后根遍历右子树
			System.out.print(t.getdata());  //访问根节点
		}
	}
	public void preroottraverse(){     //非递归先根遍历
		bitreeNode t=root;    
		if(t!=null){
			Linkstack s=new Linkstack();   //构造栈
			s.push(t);            //根节点入栈
			while(!s.isEmpty()){   
				t=(bitreeNode)s.pop();  //移除栈顶结点并返回其值
				System.out.print(t.getdata());   //访问结点
				while(t!=null){
					if(t.getlchild()!=null)   //访问左孩子
						System.out.print(t.getlchild().getdata());  //访问结点  
					if(t.getrchild()!=null)    //右孩子非空入栈
						s.push(t.getrchild());
					t=t.getlchild();
				}
			}
		}
	}
	public void inroottraverse(){  //非递归中根遍历
		bitreeNode t=root;   
		if(t!=null){
			Linkstack s=new Linkstack();
			s.push(t);
			while(!s.isEmpty()){
				while(s.peek()!=null)   //将栈顶结点所有左孩子结点入栈
					s.push(((bitreeNode)s.peek()).getlchild());
				s.pop();    //空结点退栈
				if(!s.isEmpty()){
					t=(bitreeNode)s.pop();   //移除栈顶结点并返回其值
					System.out.print(t.getdata());   //访问节点
					s.push(t.getrchild());   //结点右孩子入栈
				}
			}
		}
	}
	public void postroottraverse(){   //非递归后根遍历
		bitreeNode t=root;
		if(t!=null){
			Linkstack s=new Linkstack();
			s.push(t);
			boolean flag;    //访问标记
			bitreeNode p=null;   //p指向刚被访问的结点
			while(!s.isEmpty()){
				while(s.peek()!=null)  //栈顶结点所有左孩子结点入栈
					s.push(((bitreeNode)s.peek()).getlchild());
				s.pop();
				while(!s.isEmpty()){
					t=(bitreeNode)s.peek();  //查看栈顶元素
					if(t.getrchild()==null||t.getrchild()==p){
						System.out.print(t.getdata());  //访问结点
						s.pop();   //移除栈顶元素
						p=t;   //p指向刚被访问的结点
						flag=true;  //设置访问标记
					}
					else{
						s.push(t.getrchild());  //右孩子结点入栈
						flag=false;  //设置未被访问标记
					}
					if(!flag)
						break;
				}
			}
		}
	}
	public void leveltraverse(){   //非递归层次遍历
		bitreeNode t=root;
		if(t!=null){
			Linkqueue l=new Linkqueue();  //构造队列
			l.offer(t);   //根节点入队列
			while(!l.isEmpty()){
				t=(bitreeNode)l.poll();   //出队列
				System.out.print(t.getdata());   //访问结点
				if(t.getlchild()!=null)   //左孩子非空，入队列
					l.offer(t.getlchild());
				if(t.getrchild()!=null)   //右孩子非空，入队列   
					l.offer(t.getrchild());
			}
		}
	}
}

测试用例

package practice3;
//
public class debugbitree {
	public bitree createbitree(){
	bitreeNode d=new bitreeNode('d');
	bitreeNode g=new bitreeNode('g');
	bitreeNode h=new bitreeNode('h');
	bitreeNode e=new bitreeNode('e',g,null);
	bitreeNode b=new bitreeNode('b',d,e);
	bitreeNode f=new bitreeNode('f',null,h);
	bitreeNode c=new bitreeNode('c',f,null);
	bitreeNode a=new bitreeNode('a',b,c);
	return new bitree(a);   //创建根节点为a的二叉树
}
public static void main(String[] args){
	debugbitree s=new debugbitree();
	bitree b=s.createbitree();
	bitreeNode root=b.root; //取得树的根节点
	System.out.print("递归先根遍历");
	b.preroottraverse(root);
	System.out.print("非递归先根遍历");
	b.preroottraverse();
	System.out.println();
	System.out.print("递归中根遍历");
	b.inroottraverse(root);
	System.out.print("非递归中根遍历");
	b.inroottraverse();
	System.out.println();
	System.out.print("递归后根遍历");
	b.postroottraverse(root);
	System.out.print("非递归后根遍历");
	b.postroottraverse();
	System.out.println();
	System.out.print("层次遍历");
	b.leveltraverse();
	
}
}

运行结果