性质:
对任意一个节点,左子树和右子树高度差不能超过1
是二分搜索树
高度:左右子树中最高的树+1
平衡因子:对每个节点而言,其左右子树的高度差
右旋转(LL)
① ②
③ ④
左旋转 (RR)
① ②
③ ④
LR
RL
代码实现:
import java.util.ArrayList;
public class AVLTree<K extends Comparable<K>,V> {
private class Node {
public K key;
public V value;
public Node left, right;
public int height;
public Node(K key, V value) {
this.key = key;
this.value = value;
left = null;
right = null;
height = 1;
}
}
//根节点
private Node root;
private int size;
public AVLTree() {
root = null;
size = 0;
}
//右旋转
private Node rightRotate(Node y){
Node x = y.left;
Node T3 = x.right;
//向右旋转
x.right = y;
y.left = T3;
//更新height
y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
x.height = Math.max(getHeight(x.left), getHeight(x.right)) +1;
return x;
}
//左旋转
private Node leftRotate(Node y){
Node x = y.right;
Node T2 = x.left;
//向左旋转
x.left = y;
y.right = T2;
//更新height
y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
x.height = Math.max(getHeight(x.left), getHeight(x.right)) +1;
return x;
}
public boolean isEmpty() {
return size == 0;
}
public int getSize() {
return size;
}
private Node getNode(Node node, K key) {
if(null == node){
return null;
}
if(key.compareTo(node.key) < 0){
return getNode(node.left, key);
}
if(key.compareTo(node.key) > 0){
return getNode(node.right, key);
}
if(key.compareTo(node.key) == 0){
return node;
}
return null;
}
//获得node的高度
private int getHeight(Node node){
if(null == node){
return 0;
}
return node.height;
}
//获得node的平衡因子
private int getBlanceFactor(Node node){
if(null == node){
return 0;
}
return getHeight(node.left) - getHeight(node.right);
}
public boolean contains(K key) {
return null != getNode(root, key);
}
public V get(K key) {
Node node = getNode(root, key);
return node == null ? null : node.value;
}
public void set(K key, V newValue) {
Node node = getNode(root, key);
if(null == node){
throw new IllegalArgumentException(key+"this key is empty!");
}
node.value = newValue;
}
public void add(K key, V value) {
root = add(root, key, value);
}
//返回插入新节点后二分搜索树的根
private Node add(Node node, K key, V value){
if(node == null){
size++;
return new Node(key, value);
}
if(key.compareTo(node.key) < 0){
node.left = add(node.left, key, value);
}
else if(key.compareTo(node.key) > 0){
node.right = add(node.right, key, value);
}
else {
node.value = value;
}
//更新height
node.height = Math.max(getHeight(node.left),getHeight(node.right));
//计算平衡因子
int blanceFactor = getBlanceFactor(node);
//维护平衡
//LL
if(blanceFactor > 1 && getBlanceFactor(node.left)>=0){
return rightRotate(node);
}
//RR
if(blanceFactor < -1 && getBlanceFactor(node.right)<=0){
return leftRotate(node);
}
//LR
if(blanceFactor > 1 && getBlanceFactor(node.left) < 0){
node.left = leftRotate(node.left);
return rightRotate(node);
}
//RL
if(blanceFactor < -1 && getBlanceFactor(node.right)>0){
node.right = rightRotate(node.right);
return leftRotate(node);
}
return node;
}
//判断一棵二叉树是否是二分搜索树
public boolean isBST(){
ArrayList<K> list = new ArrayList<>();
inOrder(root, list);
for (int i = 0; i <list.size() ; i++) {
if(list.get(i + 1).compareTo(list.get(i))>0){
return false;
}
}
return true;
}
private void inOrder(Node node, ArrayList<K> keys){
if(null == node){
return;
}
inOrder(node.left, keys);
keys.add(node.key);
inOrder(node.right, keys);
}
//判断一棵二叉树是否是平衡二叉树
public boolean isBlance(){
return isBlance(root);
}
private boolean isBlance(Node node){
if(null == node){
return true;
}
int blanceFactor = getBlanceFactor(node);
if(Math.abs(blanceFactor) > 1){
return false;
}
return isBlance(node.left) && isBlance(node.right);
}
public V remove(K key) {
Node node = getNode(root, key);
if(null != node){
root = remove(root,key);
return node.value;
}
return null;
}
private Node remove(Node node,K key){
if(node == null){
return null;
}
Node retNode;
if(key.compareTo(node.key)>0){
node.right = remove(node.right,key);
retNode = node;
}
else if(key.compareTo(node.key)<0){
node.left = remove(node.left,key);
retNode = node;
}
else {
//待删除元素左子树为空
if(node.left == null){
Node rightNode = node.right;
node.right = null;
size--;
retNode = rightNode;
}
//待删除元素右子树为空
else if(node.right == null){
Node leftNode = node.left;
node.left = null;
size--;
retNode = leftNode;
}
else {
//待删除元素左右子树均不为空
//用比待删除节点大的最小的节点顶替待删除节点
Node succer = minNum(node.right);
succer.right = remove(node.right, succer.key);
succer.left = node.left;
node.left = node.right = null;
retNode = succer;
}
}
if(null == retNode){
return null;
}
//更新height
retNode.height = Math.max(getHeight(retNode.left),getHeight(retNode.right));
//计算平衡因子
int blanceFactor = getBlanceFactor(retNode);
//维护平衡
//LL
if(blanceFactor > 1 && getBlanceFactor(retNode.left)>=0){
return rightRotate(retNode);
}
//RR
if(blanceFactor < -1 && getBlanceFactor(retNode.right)<=0){
return leftRotate(retNode);
}
//LR
if(blanceFactor > 1 && getBlanceFactor(retNode.left) < 0){
retNode.left = leftRotate(retNode.left);
return rightRotate(retNode);
}
//RL
if(blanceFactor < -1 && getBlanceFactor(retNode.right)>0){
node.right = rightRotate(retNode.right);
return leftRotate(retNode);
}
return retNode;
}
private Node minNum(Node node){
if(node.left == null){
return node;
}
return minNum(node.left);
}
}