平衡二叉树（Balanced Binary Tree）具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树
右旋：在插入二叉树的时候，根节点的右侧高度大于左侧高度，且绝对值超过了2，并且在root.左侧的值大于插入的值时发生右旋 。
左右旋：在插入二叉树的时候，根节点的右侧高度大于左侧高度，且绝对值超过了2，并且在root.左侧的值小于插入的值时发生，先对root的左子树发生左旋，再对root右旋。
左旋：在插入二叉树的时候，根节点的左侧高度大于右侧，绝对值超过2，且root右侧的值小于插入的值，这个时候发生左旋。
右左旋：在插入二叉树的时候，根节点的左侧高度大于右侧，绝对值超过2，且root右侧的值大于插入的值，这个时候发生右左旋。先对root的右子树发生右旋，再对root树发生左旋。
package com.lee.test;
/**
* 平衡二叉树 插入、删除、遍历
*/
public class AVLTree {
private class Node{
private Node left;
private Node right;
private int value;
private int height = -1;
private Node (int value){
this.value = value;
}
private Node(){
}
}
private Node head; //头
public AVLTree(){
}
/**
* 获取高度
* @param root
* @return
*/
private int Height(Node root){
if (root == null){
return -1;
}else {
return root.height;
}
}
/**
* 右旋
* @return
*/
private Node rotateRight(Node root){
Node temp = root.left;
root.left = temp.right;
temp.right = root;
root.height = Math.max(Height(root.left),Height(root.right)) +1; //高度设置为两者中最高的一个
temp.height = Math.max(Height(temp.left),Height(temp.right)) +1; //高度设置为两者中最高的一个
return temp;
}
/**
* 左旋
* @return
*/
private Node rotateLeft(Node root){
Node temp = root.right;
root.right = temp.left;
temp.left = root;
root.height = Math.max(Height(root.left),Height(root.right)) +1; //高度设置为两者中最高的一个
temp.height = Math.max(Height(temp.left),Height(temp.right)) +1; //高度设置为两者中最高的一个
return temp;
}
/**
* 左右旋转
* @param node
* @return
*/
private Node rotateLeftRight(Node node){
node.left = rotateLeft(node.left);
return rotateRight(node);
}
/**
* 右左旋转
* @param node
* @return
*/
private Node rotateRightLeft(Node node){
node.right = rotateRight(node.right);
return rotateLeft(node);
}
//插入
public Node insert(Node root ,int value){
if (root == null){
root = new Node(value);
}else if(value <root.value){ //插入左边
root.left = insert(root.left,value);
if (Height(root.left) - Height(root.right) == 2){ //需要左旋
if (value < root.left.value){
root = rotateRight(root);
}else{
root = rotateLeftRight(root);
}
}
}else{
root.right = insert(root.right,value);
if (Height(root.right) - Height(root.left) ==2) //需要右旋
{
if (value > root.right.value){
root = rotateLeft(root);
}else {
root = rotateRightLeft(root);
}
}
}
root.height = Math.max(Height(root.left),Height(root.right))+1;
return root;
}
private Node deleteNode(Node root,int value) {
if(root == null) return root;//根节点null 无操作
if(value < root.value) {
root.left = deleteNode(root.left, value); //删除可能发生在左边，继续向下遍历左子树
}else if(value > root.value) {
root.right = deleteNode(root.right, value); //删除可能发生在右边，继续向下遍历右子树
}else { //找到需要删除的节点
if(root.left!=null && root.right!=null) {
//如果当前结点左右子树不为空，将问题转化为 删除一个子节点为空的节点
Node pre = root.right;
while(pre.left != null) {
pre = pre.left;
}
root.value = pre.value;
root.right = deleteNode(root.right, pre.value);
}else { //左右结点仅有一个或者都为空，删除该节点，如果有子节点 用子节点直接覆盖
root = (root.left != null) ? root.left : root.right;
}
}
//删除完成，调整平衡性
if(root == null) return root;
root.height = Math.max(Height(root.left), Height(root.right))+1;
//失衡
if(Height(root.left)-Height(root.right)>=2) {
//删除发生在右子树，模拟插入发生在左子树
if(Height(root.left.left) > Height(root.left.right)) {
//插入发生在左子树，LL旋转
return rotateLeft(root);
}else {
//LR旋转
return rotateLeftRight(root);
}
}else if(Height(root.left)-Height(root.right)<=-2){
//删除发生在左子树，模拟插入发生在右子树
if(Height(root.right.left) > Height(root.right.right)) {
//RL旋转
return rotateRight(root);
}else {
//RR旋转
return rotateRightLeft(root);
}
}
//未失衡，不做操作
return root;
}
//遍历
private void print(Node node){
if (node == null){
return;
}
print(node.left);
System.out.print(node.value+" ");
print(node.right);
// System.out.println();
}
public void add(int value){
head = insert(head,value);
}
public void delete(int value){
head = deleteNode(head,value);
}
public void show(){
print(head);
System.out.println();
}
public static void main(String args[]){
AVLTree tree = new AVLTree();
tree.add(24);
tree.add(20);
tree.add(26);
tree.add(18);
tree.add(22);
tree.add(23);
tree.add(19);
tree.add(21);
tree.add(17);
tree.add(10);
tree.add(12);
tree.add(14 );
tree.show();
tree.delete(22);
tree.show();
}
}