递归建立平衡二叉树（avl）

public class avlTest {

public static void main(String[] args) {
// TODO Auto-generated method stub
ControllAvl controller=new ControllAvl();
int []a=new int[]{4,3,5,1,7,8,6,2,9};
for(int i=0;i<a.length;i++){
controller.createAvl(a[i]);
}
controller.display();
// 4
// 3 7
// 1 5 8
// 2 6
//
}
}
/**
* 二叉树节点类
* @author Dell
*
*/
class avl implements Comparable<Integer>{
//二叉树的数据域，左右指针，二叉树节点的高度，空节点高度默认为-1，叶子节点的高度默认为0
private int data;

avl left;

avl right;

int height;

public avl(int data){
this.data=data;
this.height=0;
left=null;
right=null;
}


public int getData() {
return data;
}

public void setData(int data) {
this.data = data;
}

public int getHeight() {
return height;
}

public void setHeight(int height) {
this.height = height;
}

/**
* 重写compareTo方法，如果插入的节点值大于父节点的值，则返回1，表示插入父节点右边
*/
@Override
public int compareTo(Integer a) {
// TODO Auto-generated method stub
return this.data>a?0:1;
}

}

/**
* 包含二叉树的各种操作
* @author Dell
*
*/
class ControllAvl{
private avl root;

ControllAvl(){
this.root=null;
}

//获取二叉树节点的高度
public int getHeight(avl node){
return node==null?-1:node.height;
}
//右右情况，进行单独的左旋
public avl singleLeftRotate(avl node){
avl rightNode=node.right;
node.right=rightNode.left;
rightNode.left=node;
node.height=Math.max(getHeight(node.left), getHeight(node.right))+1;
rightNode.height=Math.max(node.height, getHeight(rightNode.right))+1;
return rightNode;
}

//左左情况，进行单独的右旋
public avl singleRightRotate(avl node){
avl leftNode=node.left;
node.left=leftNode.right;
leftNode.right=node;
node.height=Math.max(getHeight(node.left), getHeight(node.right))+1;
leftNode.height=Math.max(node.height, getHeight(leftNode.left))+1;
return leftNode;
}
//右左情况,先进行右旋，之后进行左旋
public avl rightRotateLeft(avl node){
node.right=singleRightRotate(node.right);
node=singleLeftRotate(node);
return node;
}

//左右情况，先进行左旋，之后进行右旋
public avl leftRotateRight(avl node){
node.left=singleLeftRotate(node.left);
node=singleRightRotate(node);
return node;
}

public avl createAvl(int data){
//System.out.println(data);
root=createAvl(root,data);
return root;
}
//递归的方式构建平衡二叉树
public avl createAvl(avl node,int data){
if(node==null){
//System.out.println(data);
node=new avl(data);
return node;
}
//如果是插入的data大于node的节点值，则插入到node节点的右侧
if(node.compareTo(data)==1){
//System.out.println("right");
node.right=createAvl(node.right,data);
//判断插入节点后node节点左右子树的高度差是否不超过1
if(getHeight(node.right)-getHeight(node.left)==2){
if(node.right.compareTo(data)==1){
//属于右右情况，进行左旋
System.out.println("right and right");
node=singleLeftRotate(node);
}else{
System.out.println("right and left");
//属于右左情况，先进行右旋，之后进行左旋
node=rightRotateLeft(node);
}
}
}
//如果插入的data大于node的节点值，则插入到node节点的左侧
else{
//System.out.println("left");
node.left=createAvl(node.left,data);
if(getHeight(node.left)-getHeight(node.right)==2){
if(node.left.compareTo(data)==0){
//属于左左情况,进行右旋
System.out.println("left and left");
node=singleRightRotate(node);
}
else{
//属于左右情况,先左旋，之后进行右旋
System.out.println("left and right");
node=leftRotateRight(node);
}
}
}

//计算node接待的高度
node.height=Math.max(getHeight(node.left),getHeight(node.right))+1;

return node;
}

public void display(){
//display(root);
displayFront(root);
}
public void display(avl node){
if(node!=null){
display(node.left);
System.out.println(node.getData());
display(node.right);
}
}

public void displayFront(avl node){
if(node!=null){
System.out.println(node.getData());
displayFront(node.left);
displayFront(node.right);
}
}
}