public class AVLMap<K, V> implements Iterable<AVLEntry<K, V>> {
private int size;
private AVLEntry<K, V> root;
private Comparator<K> comp;
private LinkedList<AVLEntry<K, V>> stack = new LinkedList<AVLEntry<K, V>>();
private int compare(K a, K b) {
if (comp != null) {
return comp.compare(a, b);//有比较器就用比较器比较
} else {
Comparable<K> c = (Comparable<K>) a;
return c.compareTo(b);//没有比较器就用对象本身比较
}
}
public AVLMap(Comparator<K> comp) {
super();
this.comp = comp;
}
public AVLMap() {
super();
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0 ? true : false;
}
public V put(K key, V value) {//存放节点，并把相比较过了的节点加入到stack。
if (root == null) {//第一个元素是根
root = new AVLEntry<K, V>(key, value);
stack.push(root);
size++;
} else {
AVLEntry<K, V> p = root;//每次从根节点开始比较，stack存放依次比较路上的所有节点，
while (p != null) {
stack.push(p); //调整二叉树时候用
int compareResult = compare(key, p.key);//-1:<，key<p.key
if (compareResult == 0) {
p.setValue(value);//相等就覆盖
break;
} else if (compareResult < 0) {//小于0就跟左节点比较，左节点入栈，
if (p.left == null) {
p.left = new AVLEntry<K, V>(key, value);
System.out.println(p.left);
size++;
stack.push(p.left);//刚刚加入的节点也入栈
break;
} else {// 还有左子树
p = p.left;
}
} else {
if (p.right == null) {//大于0就跟右节点比较，右节点入栈，
p.right = new AVLEntry<K, V>(key, value);
size++;
stack.push(p.right);//刚刚加入的节点也入栈
break;
} else {// 还有右子树
p = p.right;
}
}
}
}
fixAfterInsertion(key);//修改依次比较路上的所有节点的高度，
return value;
}
@Override
public Iterator<AVLEntry<K, V>> iterator() {
return new AVLIterator<K, V>(root);
}
private AVLEntry<K, V> getEntry(K key) {
AVLEntry<K, V> p = root;
while (p != null) {
int compareResult = compare(key, p.key);
if (compareResult == 0) {
return p;
} else if (compareResult < 0) {
p = p.left;
} else {
p = p.right;
}
}
return null;
}
public boolean containsKey(K key) {
AVLEntry<K, V> p = getEntry(key);
return p != null;
}
public V get(K key) {
AVLEntry<K, V> p = getEntry(key);
return p != null ? p.getValue() : null;
}
public boolean containsValue(V value) {
Iterator<AVLEntry<K, V>> itr = this.iterator();
while (itr.hasNext()) {
if (itr.next().getValue().equals(value)) {
return true;
}
}
return false;
}
public AVLEntry<K, V> getFirstEntry(AVLEntry<K, V> p) {
if (p == null) {
return null;
}
while (p.left != null) {
p = p.left;
}
return p;
}
public AVLEntry<K, V> getLastEntry(AVLEntry<K, V> p) {
if (p == null) {
return null;
}
while (p.right != null) {
p = p.right;
}
return p;
}
private AVLEntry<K, V> deleteEntry(AVLEntry<K, V> p, K key) {//从根节点开始删除，
if (p == null) {
return null;
} else {
int compareResult = compare(key, p.key);
if (compareResult == 0) {//删除就是p节点，不是删除p节点，而是修改p节点，删除的是被替换的节点。
if (p.left == null && p.right == null) {
p = null;
} else if (p.left != null && p.right == null) {
p = p.left;
} else if (p.left == null && p.right != null) {
p = p.right;
} else {//从右边和从左边开始是一样的。
if ((size & 1) == 0) {//偶数
AVLEntry<K, V> rightMin = getFirstEntry(p.right);//p.right最左边的节点，就是比p大但是最小的。
p.key = rightMin.key;
p.value = rightMin.value;//修改要删除节点p的k，v，
AVLEntry<K, V> newRight = deleteEntry(p.right, p.key);//从p.right开始删除p.key
p.right = newRight;//修改要删除节点p的right,
} else {//奇数
AVLEntry<K, V> leftMax = getLastEntry(p.left);//p.left最右的节点，就是小于p但是最大的，
p.key = leftMax.key;
p.value = leftMax.value;
AVLEntry<K, V> newLeft = deleteEntry(p.left, p.key);//从p.left开始删除p.key
p.left = newLeft;
}
}
} else if (compareResult < 0) {
AVLEntry<K, V> newLeft = deleteEntry(p.left, key);//从p.left开始删除，返回并修改新的顶点p.left
p.left = newLeft;
} else {
AVLEntry<K, V> newRight = deleteEntry(p.right, key);//从p.right开始删除，返回并修改新的顶点p.right
p.right = newRight;
}
p = fixAfterDeletion(p);
return p;//返回的是根节点
}
}
public int getHeight(AVLEntry<K, V> p) {
return p == null ? 0 : p.height;//p==null?0:Max(getHeight(p.left),getHeight(p.right))+1
}
private AVLEntry<K, V> rotateRight(AVLEntry<K, V> p) {//向右旋转，返回现在的顶节点p.left
AVLEntry<K, V> left = p.left;
p.left = left.right;
left.right = p;
p.height = Math.max(getHeight(p.left), getHeight(p.right)) + 1;//重新计算高度
left.height = Math.max(getHeight(left.left), p.height) + 1;//重新计算高度
return left;
}
private AVLEntry<K, V> rotateLeft(AVLEntry<K, V> p) {//向左旋转，返回现在的顶节点p.right
AVLEntry<K, V> right = p.right;
p.right = right.left;
right.left = p;
p.height = Math.max(getHeight(p.left), getHeight(p.right)) + 1;//重新计算高度
right.height = Math.max(p.height, getHeight(right.right)) + 1;//重新计算高度
return right;
}
private AVLEntry<K, V> firstLeftThenRight(AVLEntry<K, V> p) {
p.left = rotateLeft(p.left);//p.left.right为p.left
p = rotateRight(p);
return p;
}
private AVLEntry<K, V> firstRightThenLeft(AVLEntry<K, V> p) {
p.right = rotateRight(p.right);
p = rotateLeft(p);
return p;
}
//一路上比较的节点都要重新调整大小，因为新加进去的节点在这些节点的下面，所以这些节点都要重新调整高度。
private void fixAfterInsertion(K key) {//从新插入的节点到根节点，依次修改比较路上的节点的高度，
AVLEntry<K, V> p = root;//根
while (!stack.isEmpty()) {
p = stack.pop();//比较路上的所有节点，包括刚刚加进去的节点，第一次pop出来的是最外面的节点，
//就是刚刚加进去的节点，高度是1，然后依次修改比较路上的节点的高度。不在比较路上的节点的高度不要修改。
int newHeight = Math.max(getHeight(p.left), getHeight(p.right)) + 1;
if (p.height > 1 && newHeight == p.height) {//节点p的高度没改变
stack.clear();//那么p的上层节点高度也没改变
return;
}
p.height = newHeight;//修改高度
int d = getHeight(p.left) - getHeight(p.right);
if (Math.abs(d) <= 1) {//绝对值
continue;
} else {//左右子树高度差>=2,每次只增加一个节点，所以高度差从2开始，不会大于2，等于2就开始旋转调整。
if (d == 2) {//p左边比右边高2个，
//新插入的节点在p.left的左边，直接p右旋转，
if (compare(key, p.left.key) < 0) {
p = rotateRight(p);//返回现在的顶节点
} else {//新插入的节点在p.left的右边，先把p.left左旋转，
p = firstLeftThenRight(p);
}
} else {//-2,p右边比左边高2个，
if (compare(key, p.right.key) > 0) {//p.right的右边直接左旋转即可。
p = rotateLeft(p);//返回现在的顶节点
} else {//先p.right右旋转再p左旋转。
p = firstRightThenLeft(p);
}
}
if (!stack.isEmpty()) {//peek()不移除元素
if (compare(key, stack.peek().key) < 0) {//表示在节点stack.peek()的左边
stack.peek().left = p;//就设置左边
} else {
stack.peek().right = p;
}
}
}
}
root = p;//修改根节点
}
public void checkBalance() {//断言AVL树的平衡性
postOrderCheckBalance(root);
}
private void postOrderCheckBalance(AVLEntry<K, V> p) {
if (p != null) {
postOrderCheckBalance(p.left);
postOrderCheckBalance(p.right);
Assert.assertTrue(Math.abs(getHeight(p.left) - getHeight(p.right)) <= 1);
}
}
public V remove(K key) {
AVLEntry<K, V> entry = getEntry(key);
if (entry == null) {
return null;
}
V oldValue = entry.getValue();
root = deleteEntry(root, key);//从根节点开始删除。删除路上的所有节点都要重新调整为平衡二叉树。
size--;
return oldValue;
}
public void levelOrder() {
Queue<AVLEntry<K, V>> queue = new LinkedList<AVLEntry<K, V>>();
queue.offer(root);
int preCount = 1;
int pCount = 0;
while (!queue.isEmpty()) {
preCount--;
AVLEntry<K, V> p = queue.poll();
System.out.print(p + " ");
if (p.left != null) {
queue.offer(p.left);
pCount++;
}
if (p.right != null) {
queue.offer(p.right);
pCount++;
}
if (preCount == 0) {
preCount = pCount;
pCount = 0;
System.out.println();
}
}
}
public AVLEntry<K, V> fixAfterDeletion(AVLEntry<K, V> p) {
if (p == null) {
return null;
} else {
p.height = Math.max(getHeight(p.left), getHeight(p.right)) + 1;
int d = getHeight(p.left) - getHeight(p.right);
if (d == 2) {//左节点比右节点高2个，不可能超过2个，一次只加进去一个节点，影响高度是1，是2的时候就已经调整了。
if (getHeight(p.left.left) - getHeight(p.left.right) >= 0) {
p = rotateRight(p);//左边>=右边高可以直接右旋转p。
} else {
p = firstLeftThenRight(p);//右边比左边高，就要先把p.left左旋转，然后在右旋转p。
}
} else if (d == -2) {//右节点比左节点高2个
if (getHeight(p.right.right) - getHeight(p.right.left) >= 0) {
p = rotateLeft(p);
} else {
p = firstRightThenLeft(p);
}
}
return p;
}
}
@SuppressWarnings({ "rawtypes", "unchecked", "unused" })
public static void main(String[] args) {
AVLMap al = new AVLMap();
al.put(5d, 55d);
al.put(4d, 44d);
al.put(3d, 33d);
al.put(4.5d, 4.55d);
al.put(8d, 88d);
al.put(4.1d, 4.11d);
al.put(9d, 99d);
al.put(10d, 100d);
al.put(6.0d, 6.0d);
Iterator i = al.iterator();//[{k:4.5,L:{k:4.0,L:{k:3.0},R:{k:4.1}},R:{k:8.0L:{k:5.0},R:{k:9.0,R:{k:10.0}}}},{k:4.0,L:{k:3.0},R:{k:4.1}},{k:3.0}]
while(i.hasNext()) {
System.out.println(i.next().toString());
}
AVLEntry j = al.getEntry(4.5d);
al.levelOrder();
double o = (Double) al.remove(8d);
AVLMap<Person, Integer> map = new AVLMap<Person, Integer>(new Comparator<Person>() {
public int compare(Person o1, Person o2) {
return o2.id - o1.id;
}
});
for (int i1 = 0; i1 < 16; i1++) {
map.put(new Person(new Random().nextInt(16),
"name" + new Random().nextInt(16)),
new Random().nextInt(16));
}
Iterator<AVLEntry<Person, Integer>> itr = map.iterator();
while (itr.hasNext()) {
System.out.println(itr.next().getKey());
}
}
}
public class AVLEntry<K, V> implements Map.Entry<K, V> {
public K key;
public V value;
public AVLEntry<K, V> left;
public AVLEntry<K, V> right;
public int height = 1;//单个结点高度就是1
}
}
public class AVLIterator<K, V> implements Iterator<AVLEntry<K, V>> {//遍歷器
private Stack<AVLEntry<K, V>> stack;
public AVLIterator(AVLEntry<K, V> root) {
super();
stack = new Stack<AVLEntry<K, V>>();
addLeftPath(root);//從根開始，最左边都加进去。
}
private void addLeftPath(AVLEntry<K, V> p) {
while (p != null) {
//p入栈时候，把他的所有子左节点都加里面。右节点不在里面，出来的时候把右节点加进去（这样右节点就在里面了）， 加这个右节点时候同时把所有子左节点加进去。
//从根开始，所谓的左节点都是入栈时候加进去的，所谓的右节点都是出栈时候加进去的（加这个右节点时候也叫入栈，把所有子左节点加进去）。
stack.push(p);
p = p.left;
}
}
@Override
public boolean hasNext() {
return stack.isEmpty() ? false : true;
}
@Override
public AVLEntry<K, V> next() {
AVLEntry<K, V> p = stack.pop();//pop()是要移除元素的。
addLeftPath(p.right);//pop()出去时候把右节点加进去，加右节点时候把该节点的所有左节点加进去。
return p;
}
@Override
public void remove() {
throw new ConcurrentModificationException("Can not remove!");
}
}
