数据结构与算法——AVL树的学习与java实现

二叉平衡树

二叉平衡树又叫做AVL树，它继承了二叉搜索树的规则。
且每个节点的左子树和右子树的高度差最多差1。
二叉平衡树由于不会产生像二叉搜索树那样的极端情况，所以查找，删除(懒惰删除)的时间复杂度为o(logn)。插入操作需要对树作出调整，所以时间复杂度略高于o(logn)。
如下图所示：第一张图为AVL树，第二张图则不是AVL树

在这里插入图片描述

AVL树的旋转

插入操作需要满足AVL树的特性：每个节点的左子树和右子树的高度差最多差1。把必须重新平衡的节点叫作a。由于任意结点最多有两个儿子，因此高度不平衡时，a点的两棵子树的高度差2。将会出现以下四种不平衡的情况：

1.对a的左儿子的左子树进行一次插入。

2.对a的左儿子的右子树进行一次插入。

3.对a的右儿子的左子树进行一次插入。

4.对a的右儿子的右子树进行一次插入。

对于1、4两种情况可以通过单旋转达到平衡条件。对于2、3两种情况可以通过双旋转达到平衡条件。
右旋转的步骤：【左旋转类似】

建一个新节点，值等于当前节点的值、
把新节点的右子树设置为当前结点的右子树
新节点的左子树设置为当前结点的左子树的右子树
当前结点的值换为左子树节点的值
把当前结点的左子树设置为左子树的左子树
把当前结点的右子树设置为新节点
旋转过程图解：

AVL树的具体实现

核心代码实现：

/**
	 * 获取左子树的高度
	 * @return
	 */
	public int leftHeight() {
	if(left==null) {
			return 0;
		}
	return left.height();
	}
	/**
	 * 获取右子树的高度
	 * @param node
	 */
	public int rightHeight() {
		if(right==null) {
				return 0;
			}
		return right.height();
		}
		/*
 * 向子树中添加节点
 */
	public void add(Node node) {
		// TODO Auto-generated method stub
		if(node==null) {
			return;
		}
			//判断传入的节点的值比当前子树的根节点的值是大是小
			//添加的节点比当前结点更小
			if(node.value<this.value) {
				//如果左节点为空
				if(this.left==null) {
					this.left=node;
					//如果不为空
				}else {
					this.left.add(node);
				}
				//右子树
			}else {
				if(this.right==null) {
					this.right=node;
					//如果不为空
				}else {
					this.right.add(node);
				}
			}
			//查找是否平衡
			 //检查左子树和右子树的高度
			//进行右旋转
			if(leftHeight()-rightHeight()>=2) {
				//双旋转
				if(left!=null&&left.leftHeight()<left.rightHeight()) {
					//先左旋转
					left.leftRotate();
					//再右旋转
					RightRotate();
					//单旋转
				}else {
				RightRotate();
				}
			//左旋转	
			}
			if(leftHeight()-rightHeight()<=-2) {
				//双旋转
				if(right!=null&&right.rightHeight()<right.leftHeight()) {
					right.leftRotate();
					leftRotate();
					//单
				}else {
					leftRotate();
				}	
			}
		}
/**
 * 左旋转
 */
	private void leftRotate() {
		Node newLeft=new Node(value);
		newLeft.left=left;
		newLeft.right=right.left;
		value=right.value;
		right=right.right;
		left=newLeft;
}
	/**
	 * 右旋转
	 * @param node
	 */
	private void RightRotate() {
		//创建一个新节点，值等于当前节点的值
		Node newRight=new Node(value);
		//把新节点的右子树设置为当前结点的右子树
		newRight.right=right;
		//把新节点的左子树设置为当前结点的左子树的右子树
		newRight.left=left.right;
		//把当前结点的值换为左子树节点的值
		value=left.value;
		//把当前结点的左子树设置为左子树的 左子树
		left=left.left;
		//把当前结点的右子树设置为新节点
		right=newRight;	
}

完整java代码实现：

package demo10;

public class Node {
	int value;
	Node left;
	Node right;
	
	public Node (int value) {
		this.value=value;
	}
	/**
	 * 返回当前结点的高度
	 * @param node
	 */
	public int height() {
		return Math.max(left==null?0:left.height(),right==null?0: right.height())+1;
	}
	/**
	 * 获取左子树的高度
	 * @return
	 */
	public int leftHeight() {
	if(left==null) {
			return 0;
		}
	return left.height();
	}
	/**
	 * 获取右子树的高度
	 * @param node
	 */
	public int rightHeight() {
		if(right==null) {
				return 0;
			}
		return right.height();
		}
	
/*
 * 向子树中添加节点
 */
	public void add(Node node) {
		// TODO Auto-generated method stub
		if(node==null) {
			return;
		}
			//判断传入的节点的值比当前子树的根节点的值是大是小
			//添加的节点比当前结点更小
			if(node.value<this.value) {
				//如果左节点为空
				if(this.left==null) {
					this.left=node;
					//如果不为空
				}else {
					this.left.add(node);
				}
				//右子树
			}else {
				if(this.right==null) {
					this.right=node;
					//如果不为空
				}else {
					this.right.add(node);
				}
			}
			//查找是否平衡
			 //检查左子树和右子树的高度
			//进行右旋转
			if(leftHeight()-rightHeight()>=2) {
				//双旋转
				if(left!=null&&left.leftHeight()<left.rightHeight()) {
					//先左旋转
					left.leftRotate();
					//再右旋转
					RightRotate();
					//单旋转
				}else {
				RightRotate();
				}
			//左旋转	
			}
			if(leftHeight()-rightHeight()<=-2) {
				//双旋转
				if(right!=null&&right.rightHeight()<right.leftHeight()) {
					right.leftRotate();
					leftRotate();
					//单
				}else {
					leftRotate();
				}	
			}
		}
/**
 * 左旋转
 */
	private void leftRotate() {
		Node newLeft=new Node(value);
		newLeft.left=left;
		newLeft.right=right.left;
		value=right.value;
		right=right.right;
		left=newLeft;
}
	/**
	 * 右旋转
	 * @param node
	 */
	private void RightRotate() {
		//创建一个新节点，值等于当前节点的值
		Node newRight=new Node(value);
		//把新节点的右子树设置为当前结点的右子树
		newRight.right=right;
		//把新节点的左子树设置为当前结点的左子树的右子树
		newRight.left=left.right;
		//把当前结点的值换为左子树节点的值
		value=left.value;
		//把当前结点的左子树设置为左子树的 左子树
		left=left.left;
		//把当前结点的右子树设置为新节点
		right=newRight;	
}

	
	
/*
 * 中序遍历二叉排序,中序遍历二叉排序树结果为从小到大的顺序
 */
	public void midShow(Node node) {
		if(node==null) {
			return;
		}
		midShow(node.left);
		System.out.println(node.value);
		midShow(node.right);
	}
	/**
	 * 查找节点
	 */
	public Node search(int value) {
		if(this.value==value){
			return this;
	}else if(value<this.value){
		if(left==null) {
			return null;
		}
		return left.search(value);
	}else{
		if(right==null) {
			return null;
		}
		return right.search(value);
		}
	}
	/**
	 * 搜索父节点
	 */
	public Node searchParent(int value) {
		if((this.left!=null&&this.left.value==value)||(this.right!=null&&this.right.value==value)) {
			return this;
		}else {
			if(this.value>value&&this.left!=null) {
				return this.left.searchParent(value);
			}else if(this.value<value&&this.right!=null){
				return this.right.searchParent(value);
			}
			return null;
		}
	}
}

package demo10;

public class BinarySortTree {
	Node root;
	/*
	 * 向二叉排序树中添加节点
	 */
	public void add(Node node) {
		//如果是一颗空树
		if(root==null) {
			root=node;
		}else {
			root.add(node);
		}
	}
	/*
	 * 中序遍历二叉排序树
	 */
	public void midShow() {
		if(root!=null) {
			root.midShow(root);
		}
	}
	/*
	 * 查找节点
	 */
	public Node search(int value) {
		if(root==null) {
			return null;
		}else {
			return root.search(value);
		}
	}
	
	/**
	 * 删除节点
	 */
	public void delete(int value) {
		if(root==null) {
			return;
		}else {
			//找到这个节点
			Node target=search(value);
			//如果没有这个节点
			if(target==null) {
				return;
			}
			//找到他的父节点
			 Node parent=searchParent(value);
			//要删除的节点是叶子节点
			 if(target.left==null&&target.right==null) {
				 //要删除的节点是父节点的左子节点
				 if(parent.left.value==value) {
					 parent.left=null;
					 //要删除的节点是右节点
				 }else {
					 parent.right=null;
				 }
				 //要删除的节点有两个子节点 
			 }else if(target.left!=null&&target.right!=null) {
				 //删除右子树中值最小的节点，取刚获取到该节点的值
				 int min=deleteMin(target.right);
				 //替换目标节点中的值
				 target.value=min;
				//要删除的节点有一个左子节点或右字节点 
			 }else {
				 if(target.left!=null) {
					 //
					 if(parent.left.value==value) {
						 parent.left=target.left;
						 //要删除的节点是右节点
					 }else {
						 parent.right=target.right;
					 }
					 
				//右子节点	 
				 }else {
					 if(parent.right.value==value) {
						 parent.right=target.right;
						 //要删除的节点是右节点
					 }else {
						 parent.right=target.right;
					 }
					 
				 }
			 }
		}
	}
	/**
	 * 删除一颗树中最小的值的节点
	 * @param right
	 * @return
	 */
	private int deleteMin(Node node) {
		Node target=node;
		//递归向左找
		while(target.left!=null) {
			target=target.left;
		}
		//删除最小值的这个节点
		delete(target.value);
		return target.value;
	}
	/*
	 * 搜索父节点
	 */
	public Node searchParent(int value) {
		if(root==null) {
			return null;
		}else {
			return root.searchParent(value);
		}
	}
}

package demo10;

public class TestBinarySortTree {
	public  static void main(String[] args) {
	//int [] arr=new int [] {8,9,6,7,5,4};
	int [] arr=new int [] {8,9,5,4,6,7};
	//创建一颗二叉排序树
	BinarySortTree bst=new  BinarySortTree();
	//循环添加
	for(int i:arr) {
		bst.add(new Node(i));
		}
	System.out.println(bst.root.height());
	System.out.println(bst.root.value);
	}
}

此篇文章内容参考了以下这篇文章进行学习与总结。
二叉平衡树

无名king

发布了28 篇原创文章 · 获赞 5 · 访问量 3718

私信关注

数据结构与算法——AVL树的学习与java实现

二叉平衡树

AVL树的旋转

AVL树的具体实现

猜你喜欢