版权声明:本文为博主原创文章,未经博主允许不得转载。 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();
}
}
运行结果