二叉平衡树

AVLTree实现

public class AVLTree<K,V>extends BinarySearchTree<K,V>{
	@Override
	public void insert(K key,V value){
	//先按照bst的方式插入在调整
		BSTNode<K,V>nnode=super.insert(key,value);
		BSTNode<K,V>[]pqs=firstUnBalance(nnode);//找到第一个不平衡的节点
		if(pqs!=null)reBanlace(pqs);//调整
		return nnode;
}
	public BSTNode<K,V>[]firstUnBalance(BSTNode<K,V>n){
		if(n==null)return null;
		BSTNode<K,V>s=n;
		BSTNode<K,V>q=s.parent;
		if(p==null)return null;
		BSTNode<K,V>p=q.parent;
		if(p==null)return null;
		if(unBalance(p)){
			return new BSTNode<K,V>[]{p,q,s};
		}else{
			firstUnBalance(q);
		}
}
	public void reBalance(BSTNode<K,V>[]pqs){
		if(pqs==null)return;
		BSTNode<K,V>p=pqs[0];
		BSTNode<K,V>q=pqs(1);
		BSTNode<K,V>s=pqs(2);
		if(s.isRight()&&q.isRight()){//右右型
			leftRotate(p,q);//以p为中心左旋
		}else if(s.isLeft()&&q.isLeft()){
			rightRotate(p,q);//以p为中心右旋
		}else if(q.isLeft()&&s.isRight()){//左右型
			leftRotate(q,s);//以q为中心左旋
			rightRotate(p,s);//左旋后变为左左型，再以p为中心右旋
		}else{//右左型
			rightRotate(q,s);//以q为中心右旋，变为右右型
			leftRotate(p,s);//以p为中心左旋
		}
}
	//左旋
	protected void leftRotate(BSTNode<K,V>p,BSTNode<K,V>q){
		boolean pIsLeft=p.isLeft();
		BSTNode<K,V>pp=p,parent;
		//p和q左子的关系
		BSTNode<K,V>x=q.left;	
		p.right=x;
		if(x!=null){
			x.parent=p;
			x.isLeft=false;
		}
		//处理p和q的关系
		q.left=p;
		p.parent=q;
		p.isLeft=true;
		//处理q和pp的关系
		if(pp==null){
			root=q;
			return;
		}else if(pIsLeft){//p一开始为左子
			pp.left=q;
			q.parent=pp;
			q.isLeft=true;
		}else{//p一开始为右子
			pp.right=q;
			q.parent=pp;
			q.isLeft=false;
		}
	}
	//右单旋
	protected void rightRotate(BSTNode<K,V>p,BSTNode<K,V>q){
		BSTNode<K,V>pp=p.parent;
		boolean pIsLeft=p.isLeft();
		//p和q右子的关系
		BSTNode<K,V>x=q.right;
		p.left=x;
		if(x!=null){
			x.parent=p;
			x.isLeft=true;
		}
		//p和q的关系
		q.right=p;
		p.parent=q;
		p.isLeft=false;
		//q和pp的关系
		if(pp==null){
			root=q;
		}else if(pIsLeft){//p一开始为左子
			pp.left=q;
			q.parent=pp;
			q.isLeft=true;
		}else{
			pp.right=q;
			q.parent=pp;
			q.isLeft=false;
		}
 	}
	@Override
	public void remove(K key){
		BSTNode<K,V>node=super.lookupNode(key);
			if(node==null)return;
		BSTNode<K,V>left=node.left;
		BSTNode<K,V>right=node.right;
		BSTNode<K,V>parent=node.parent;
		if(left==null&&right==null){
			super.remove(node);
			reBalance(parent);
		}else if(right==null){//无右子,有左子
			BSTNode<K,V>predecessor=maxNode(node.left);
			BSTNode<K,B>predecessorParent=predecessor.parent;
			super.remove(predecessor);
			node.key=predecessor.key;
			node.value=predecessor.value;
			reBalance(predecessorParent);
		}else{
			BTSNode<K,V>successor=minOf(node.right);
			BSTNode<K,V>successorParent=successor.parent;
			super.remove(successor);
			node.key=successor.key;
			node.value=successor.value;
			reBalance(successorParent);
		}
}
	public void reBalance(BSTNode<K,V>node){
		if(node==null)return;
		int hRight=super.getHeight(node.right);
		int hLeft=super.getHeight(node.left);
		if(hRight-hLeft>=2){//右侧高
			leftRotate(node,node.right);
			reBalance(node.right);
		}else if(hRight-hLeft<=-2){//左侧高
			rightRotate(node,node.left);
			reBalance(node.left);
		}else{
			reBalance(node.parent);
		}
}
}