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

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##*