二叉树的各种实现（创建，叶子结点数，是否为堆，完全二叉树，二叉查找树，交换左右孩子）

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;


public class BTree<AnyType  extends Comparable<? super AnyType>> {

	BTNode root=new BTNode();
	
	 class BTNode<AnyType>{
		char data;
		BTNode<AnyType> left;
		BTNode<AnyType> right;
		public BTNode(){
			data=0;
			left=right=null;
		}
		public BTNode(char data){
			this.data=data;
			left=right=null;
		}
		
	}
		int num=0;      //计算节点数
	 //先序创建二叉树
        char d[]=new char[100];
		int i=0;
		public BTNode preCreatTree(){
			BTNode node=null;
		    if(d[i]!='*'){
			    if(d[i]=='#'){
				    node=null;
				    i++;
			    }
			    else{
			    	num++;
				    node=new BTNode(d[i]);
				    i++; 
				    node.left=preCreatTree();   
				    node.right=preCreatTree();			
			}
			}
			return node;
		}
	    //层次非递归遍历
		public void levelOrder(BTNode root){
			int i=0;
			Queue<BTNode> q=new LinkedList<BTNode>();
			q.add(root);
			while(q.isEmpty()!=true){
				BTNode step=q.remove();
				System.out.print(step.data);
				if(step.left!=null){
					q.add(step.left);
				}
				if(step.right!=null){
					q.add(step.right);
				}
			}
			System.out.println();
		}
		//叶子结点个数
		int count=0;                 //统计叶子个数
		public int leaf(BTNode root){
			if(root!=null){
				if(root.left==null&&root.right==null)
					count++;
				leaf(root.left);
				leaf(root.right);
			}
			return count;
		}
		
		//交换左右子树
		public void exchange_left_right(BTNode root){
			if(root==null)
				return;
			BTNode step=root.left;
			root.left=root.right;
			root.right=step;
			exchange_left_right(root.left);
			exchange_left_right(root.right);
		}	
   
  //判断一棵二叉树是否为完全二叉树,如果是，转换成顺序存储
	char comp[];

	//Queue<BTNode> qc=new LinkedList<BTNode>();
	public boolean isCompBTree(BTNode root){
		BTNode r=root;
		boolean isComp=true;                       //是否是完全二叉树
		boolean noHasTwoChild=false;               //是否没有两个孩子，即只有一个孩子或没有孩子	                          
		Queue<BTNode> q=new LinkedList<BTNode>();
		q.add(root);
		while(!q.isEmpty()){
			BTNode p=q.remove();
			if(!noHasTwoChild){                             //找到第一个只有左孩子或没有孩子的点后，转向else，不再走这部分
				if(p.left!=null&&p.right!=null){            //既有左孩子，又有右孩子
					q.add(p.left);
					q.add(p.right);
					
				}
				if(p.left!=null&&p.right==null){           //有左无右
					noHasTwoChild=true;
					q.add(p.left);
				}
				if(p.left==null&&p.right!=null){           //有右无左，不是完全二叉树
					noHasTwoChild=true;
					isComp=false;
					break;
				}
				if(p.left==null&&p.right==null){                                      //无左无右
					noHasTwoChild=true;
				}
			}
			if(noHasTwoChild){                                        //已经找到没有两个孩子的点，若其后存在一点有孩子，则不是完全二叉树
				if(p.left!=null||p.right!=null){
					isComp=false;
					break;
				}
			}
		}
		if(isComp)	
		    return true; 
	    else
			return false;
	}
	public int number(BTNode root){
		return num;
	}
//转成顺序存储
	public char[] sx(BTNode root){
		if(isCompBTree(root)==true){
			Queue<BTNode> q=new LinkedList<BTNode>();
		    char comp[]=new char[num];
		    System.out.println(num);
	        q.add(root);
	        int i=0;
			while(!q.isEmpty()){
				BTNode step=q.remove();
				comp[i]=step.data;
				System.out.println(comp[i]);
				i++;
				if(step.left!=null){
					q.add(step.left);
				}
				if(step.right!=null){
					q.add(step.right);
				}
			}		
		
		}
		 return comp;
	}
/*//判断一棵二叉树是不是堆
	public boolean isHeap(BTNode root){
		char h[]=sx(root);
		int temp=2;
		if(h.length>=3){
			if(h[1]>h[2]&&h[1]>h[3]){                 //大顶堆
				while(temp<=(number(root)/2)&&h[temp]>=h[temp]&&h[temp]>=h[temp*2+1]){
					temp++;
				}
				if(temp==number(root)/2+1)
					return false;
				else
					return true;	

			}
			else if(h[1]<h[2]&&h[1]<h[3]){                     //小顶堆
				while(temp<=(number(root)/2)&&h[temp]<h[temp]&&h[temp]<h[temp*2+1])
				{
					temp++;
				}
				if(temp==number(root)/2+1)
					return true;
				else
					return false;
				
			}
			else
				return false;
		}
		else
			return false;
	}
	
	*/
	//判断一棵二叉树是不是堆，有点麻烦
	public boolean isHeap(BTNode root){
		boolean isheap=true;         //是否是堆
		boolean flag=true;           //flag==true,根最大
		int count=0;
		Queue<BTNode> qd=new LinkedList<BTNode>();
		if(isCompBTree(root)){        //是完全二叉树
			qd.add(root);
			while(!qd.isEmpty()){
				BTNode step=qd.remove();
				if(step.left!=null){      //判断是否是叶子
					if(step.right!=null){   //有两个孩子       
						 compareLeft=((AnyType)(Object)step.left.data).compareTo((AnyType)(Object)step.data);
					     compareRight=((AnyType)(Object)step.right.data).compareTo((AnyType)(Object)step.data);
						//System.out.println(step.left.data);
						 //System.out.println(step.right.data);
					     if(flag==true&&compareLeft<=0&&compareRight<=0){      //根节点最大的堆
								count++;
						 if(step.left.left!=null)          //左孩子不是叶子
								     qd.add(step.left);
	                            if(step.right.left!=null)         //右孩子不是叶子
								     qd.add(step.right);
							}
					     if(flag==true&&(compareLeft>0||compareRight>0)){    //不满足树或子树根最大
					    	 if(count!=0){                         //有些结点满足根最大
					    		 isheap=false;	                 //不是堆
					    		 break;
					    	 }	 
					    	 flag=false;                          //否则令flag=false，判断其是否为根最小的堆
					     }
					    
					    if(flag==false&&compareLeft>=0&&compareRight>=0){          //根节点最小的堆
					    	 if(step.left.left!=null)
							     qd.add(step.left);
                             if(step.right.left!=null)
							     qd.add(step.right);
					     }
					    if(flag==false&&(compareLeft<0||compareRight<0)){       //不满足根最小         				    	 
					    	isheap=false;                //不是堆
					    	break;
					     }
					}
					else{                      //有一个孩子，
						compareLeft=((AnyType)(Object)step.left.data).compareTo((AnyType)(Object)step.data);
						compareRight=0;
						if(flag==true&&compareLeft<=0){      //根节点最大的堆
							count++;
							if(step.left.left!=null)
							     qd.add(step.left);
						}
				        if(flag==true&&compareLeft>0){
				    	    if(count!=0){
				    		   isheap=false;
				    		    break;
				    	     } 	 
				    	     flag=false;
				     }
				    
				     if(flag==false&&compareLeft>0){          //根节点最小的堆
				    	 if(step.left.left!=null)
						     qd.add(step.left);
				     }
				     if(flag==false&&compareLeft<=0){ 
				    	isheap=false;
				    	break;
				     }
						
					}						
				}
	
			}
		}
		else{
			isheap=false;
		}
		return isheap;
	}
 
	//判断是否为二叉查找树
		int compareLeft;
		int compareRight;
		public boolean ifBSTree(BTNode root){
			if(root!=null){
				if(root.left!=null&&root.right!=null){
				     compareLeft=((AnyType)(Object)root.left.data).compareTo((AnyType)(Object)root.data);
				     compareRight=((AnyType)(Object)root.right.data).compareTo((AnyType)(Object)root.data);
				}
				if(root.right!=null&&root.left==null){
				      compareRight=((AnyType)(Object)root.right.data).compareTo((AnyType)(Object)root.data);
				      compareLeft=-1000;
				}
				if(root.right==null&&root.left!=null){
					compareLeft=((AnyType)(Object)root.left.data).compareTo((AnyType)(Object)root.data);
					 compareRight=1000;
				}
				 if(compareLeft>=0||compareRight<=0)
					return false;
				else{
					ifBSTree(root.left);
					ifBSTree(root.right);
				}
					
			}
			return true;
		}
	public static void main(String[] args) {
		BTree bt=new BTree();
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入数据：");
		String a=sc.next();
		char b[]=a.toCharArray();
		for(int i=0;i<b.length;i++){
		     bt.d[i]=b[i];
		}
		bt.root=bt.preCreatTree();

		System.out.print("层次遍历: ");
		bt.levelOrder(bt.root);
		
		System.out.print("叶子结点个数     ");
		System.out.println(bt.leaf(bt.root));
		
		System.out.print("是否为二叉查找树    ");
		System.out.println(bt.ifBSTree(bt.root));
		
		System.out.println("是否为完全二叉树    "+bt.isCompBTree(bt.root));
		
		System.out.println("是否为堆    "+bt.isHeap(bt.root));
	
		System.out.print("交换左右子树后层次遍历      ");
		bt.exchange_left_right(bt.root);
		bt.levelOrder(bt.root);
	}

}


//abd###ce##f##*

版权声明：本文为博主原创文章，未经博主允许不得转载。