平衡二叉树AVL

于 2021-06-28 13:51:02 发布
阅读量292 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wdquan19851029/article/details/118301132
版权

1.概述:

为什么引入平衡二叉树？二叉排序树（BST）存在问题：已经排序过的数组，例如{1,2,3,4,5}，转化为二叉排序树时，其实就是一个单链表，完全没有二叉排序树的优势，甚至查找的时候比单链表还要慢（需要判断左子树）

平衡二叉树(AVL树)：对BST的升级，它是一颗空树，或者左、右子树高度差的绝对值不能超过1（所有节点的左右子树高度差不超过1)），并且左右两颗子树也都是平衡二叉树。在一棵具有N 个节点的树中，我们希望该树的高度能够维持在logN左右，插入和查找效率都能保证在对数的时间复杂度内完成（时间复杂度为对数阶）。

实现方法：红黑树、AVL、替罪羊树、Treap、伸展树等。

平衡二叉树的缺点：每次增删之后，都要进行平衡，会降低效率

2.实现思路:

1.左旋转：

如果BST的右子树高度-左子树高度>1，左旋转：

  1. 用当前根节点的值，创建新节点
  2. 将新节点的左子树设置为根节点的左子树
  3. 将新节点的右子树设置为根节点右子树的左子树
  4. 把根节点的值替换为其右子树的值
  5. 把根节点的右子树设置为其右子树的右子树。
  6. 把根节点的左子节点设置为新节点

2.右旋转：

如果BST的左子树高度-右子树高度>1，右旋转：与左旋转相反

  1. 用当前根节点的值，创建新节点
  2. 将新节点的右子树设置为根节点的右子树
  3. 将新节点的左子树设置为根节点左子树的右子树
  4. 把根节点的值替换为其左子树的值
  5. 把根节点的左子树设置为其左子树的左子树。
  6. 把根节点的右子节点设置为新节点

3.双旋转：

  • 左子树高于右子树,但是左子树的右子树高度，大于左子树的左子树的高度(靠内的子树的高度高)，那么先对左子树做左旋转，然后根节点进行右旋转
  • 右子树高于左子树,但是右子树的左子树高度，大于右子树的右子树的高度(靠内的子树的高度高)，那么先对右子树做右旋转，然后根节点进行左旋转

3.代码实现：

首先必须实现以下方法：

  • 计算树的高度方法
  • 计算左子树的高度的方法
  • 计算右子树的高度的方法
  • 左旋方法
  • 右旋方法

在对BST树进行增删之后，要立即判断树的左右子树的高度，如果不满足平衡二叉树的要求，则根据情况进行左旋转、右旋转或者双旋转

具体代码如下:

package com.bruce.binarytree;

/**
 * 二叉排序树（BST）存在问题：已经排序过的数组，例如{1,2,3,4,5}，转化为二叉排序树时，其实就是一个单链表，完全没有二叉排序树的优势，甚至查找的时候比单链表还要慢（需要判断左子树）
 * 平衡二叉树(AVL树)：对BST的升级？？？ 它是一颗空树，或者左右子树高度差的绝对值不能超过1，并且左右两颗子树也都是平衡二叉树。
 * 实现方法：红黑树、AVL、替罪羊树、Treap、伸展树等。
 * 缺点：每次增删之后，都要进行平衡，会降低效率
 * @author bwang018
 *
 */
public class AVLBinaryTree {

	public static void main(String[] args) {
	    // TODO Auto-generated method stub
	    //1.右子树高于左子树，左旋转
//	    int [] array = {4,3,6,5,7,8};
		
	    //2.左子树高于右子树，右旋转
//	    int [] array = {10,12,8,9,7,6};
		
	    //3.双旋转：左子树高于右子树,但是左子树的右子树高度，大于左子树的左子树的高度(靠内的子树的高度高)，那么先对左子树做左旋转
	    int [] array = {10,11,7,6,8,9};
		
	    //4.双旋转：右子树高于左子树,但是右子树的左子树高度，大于右子树的右子树的高度(靠内的子树的高度高)，那么先对右子树做右旋转
//	    int [] array = {2,1,6,5,7,3};
		
	    AVLTree avlTree = new AVLTree();
	    for (int i = 0; i < array.length; i++) {
	        avlTree.add(new AVLNode(array[i]));
	    }
	    //中序遍历AVL树
	    System.out.println("中序遍历......");
	    avlTree.infixOrder();
	    
	    System.out.println("平衡处理......");
	    System.out.println("树的高度=" + avlTree.root.height());
	    System.out.println("树的左子树高度=" + avlTree.root.leftHeight());
	    System.out.println("树的右子树高度=" + avlTree.root.rightHeight());
	    System.out.println("当前的根节点" + avlTree.root);
	    System.out.println("根节点的左子节点" + avlTree.root.leftNode);
	    System.out.println("根节点的右子节点" + avlTree.root.rightNode);
	}

}

class AVLTree{
	AVLNode root;
	public void add(AVLNode node){
		if (root == null) {
			root = node;
		}else {
			root.add(node);
		}
	}
	
	//将非AVL树转为AVL树
	public void rightRotate(){
		int leftHeight = root.leftHeight();
		int rightHeight = root.rightHeight();
		if (Math.abs(leftHeight - rightHeight) > 1) {
			root.leftRotate();
		}
	}
	
	//中序遍历
	public void infixOrder(){
		if (root == null) {
			System.out.println("二叉树为空，不能遍历");
			return;
		}
		root.infixOrder();
	}
	
}
class AVLNode{
	public int value;
	public AVLNode leftNode;
	public AVLNode rightNode;
	
	
	public AVLNode(int value) {
		super();
		this.value = value;
	}
	
	public int getValue() {
		return value;
	}
	public void setValue(int value) {
		this.value = value;
	}
	public AVLNode getLeftNode() {
		return leftNode;
	}
	public void setLeftNode(AVLNode leftNode) {
		this.leftNode = leftNode;
	}
	public AVLNode getRightNode() {
		return rightNode;
	}
	public void setRightNode(AVLNode rightNode) {
		this.rightNode = rightNode;
	}
	
	public void add(AVLNode node){
		if (node == null) {
			return;
		}
		if (node.value < this.value) {
			if (null == this.leftNode) {
				this.leftNode = node;
			}else {
				//递归地向左子树添加
				this.leftNode.add(node);
			}
		}else {
			if (null == this.rightNode) {
				this.rightNode = node;
			}else {
				//递归地向右子树添加
				this.rightNode.add(node);
			}
		}
		//当添加节点完成后，如果右子树的高度比左子树的高度 > 1，那么需要左旋转
		if (rightHeight() - leftHeight() > 1) {
			//如果右子树的左子树高度，大于右子树的右子树的高度，那么先对右子树做右旋转
			if (rightNode != null && rightNode.leftHeight() > rightNode.rightHeight()) {
				//对左子树做左旋转
				rightNode.rightRotate();
			}
			leftRotate();
			return;
		}
		//当添加节点完成后，如果左子树的高度比右子树的高度 > 1，那么需要右旋转
		if (leftHeight() - rightHeight() > 1) {
			//如果左子树的右子树高度，大于左子树的左子树的高度，那么先对左子树做左旋转
			if (leftNode != null && leftNode.rightHeight() > leftNode.leftHeight()) {
				//对左子树做左旋转
				leftNode.leftRotate();
			}
			rightRotate();
		}
	}
	
	//中序遍历
	public void infixOrder(){
		if (this.leftNode != null) {
			this.leftNode.infixOrder();
		}
		System.out.println(this);
		if (this.rightNode != null) {
			this.rightNode.infixOrder();
		}
	}
	
	//查找要删除的节点
	public AVLNode search(int value){
		if (this.value == value) {
			return this;
		}else if (this.value > value) {
			if (this.leftNode == null) {
				return null;
			}else {
				return this.leftNode.search(value);
			}
		}else {
			if (this.rightNode == null) {
				return null;
			}else {
				return this.rightNode.search(value);
			}
		}
	}
	
	//查找要删除节点的父节点
	public AVLNode searchParent(int value){
		//如果当前节点就是要删除节点的父节点，直接返回this
		if ((this.leftNode != null && this.leftNode.value == value) || (this.rightNode != null && this.rightNode.value == value)) {
			return this;
		}else {
			if (this.value > value && this.leftNode != null) {
				return this.leftNode.searchParent(value);
			}else if(this.value <= value && this.rightNode != null){ //防止有相同的值不能被遍历到，这里要用=
				return this.rightNode.searchParent(value);
			}else {
				return null;
			}
		}
	}
	
	//以当前节点为根节点，计算树的高度
	public int height(){
		return Math.max(leftNode == null ? 0:leftNode.height(), rightNode == null ? 0: rightNode.height()) + 1;
	}
	
	//当前节点左子树的高度
	public int leftHeight(){
		if (leftNode == null) {
			return 0;
		}
		return leftNode.height();
	}
	
	//当前节点右子树的高度
	public int rightHeight(){
		if (rightNode == null) {
			return 0;
		}
		return rightNode.height();
	}
	
	//AVL 左旋转方法: 右子树高度-左子树高度 > 1
	public void leftRotate(){
		//用当前根节点的值，创建新节点
		AVLNode newAvlNode = new AVLNode(value);
		//将新节点的左子树设置为根节点的左子树
		if (leftNode != null) {
			newAvlNode.leftNode = leftNode;
		}
		//把新节点的右子树设置为根节点右子树的左子树
		if (rightNode != null && rightNode.leftNode != null) {
			newAvlNode.rightNode = rightNode.leftNode;
		}
		if (rightNode != null) {
			//把根节点的值替换为其右子节点的值
			value = rightNode.value;
			//把根节点的右子树设置为其右子树的右子树。
			rightNode = rightNode.rightNode;
		}
		//把根节点的左子节点设置为新节点
		leftNode = newAvlNode;
		
	}
	
	//AVL 右旋转方法: 左子树高度-右子树高度 > 1
	public void rightRotate(){
		//用当前根节点的值，创建新节点
		AVLNode newAvlNode = new AVLNode(value);
		//将新节点的右子树设置为根节点的右子树
		if (rightNode != null) {
			newAvlNode.rightNode = rightNode;
		}
		//把新节点的左子树设置为根节点左子树的右子树
		if (leftNode != null && leftNode.rightNode != null) {
			newAvlNode.leftNode = leftNode.rightNode;
		}
		if (rightNode != null) {
			//把根节点的值替换为其左子树的值
			value = leftNode.value;
			//把根节点的左子树设置为其左子树的左子树。
			leftNode = leftNode.leftNode;
		}
		//把根节点的右子节点设置为新节点
		rightNode = newAvlNode;
		
	}
	
	@Override
	public String toString() {
		return "AVLNode [value=" + value + "]";
	}
}

困知勉行1985
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
平衡二叉树（AVL树）
qq_40889155的博客
08-02 596
平衡二叉树二叉排序树的优缺点平衡二叉树 二叉排序树的优缺点 优点：首先二叉排序树是以链接的方式存储的，所以在插入或者删除元素时不需要移动元素，插入和删除的性能较好。 缺点：二叉排序树的查找是走根节点到目标节点的路径，最多不会超过树的深度。也就是说，二叉排序树的查找性能取决于二叉树的形状，但问题是，二叉排序树的形状是不确定的。 例如：将{5,8,4,9,3,7,1,2,6}数组构建成二叉排序树，如图 平衡二叉树 平衡二叉树(Self-Balancing Binary Search Tree 或 Height-
二叉树，平衡二叉树，红黑树，b树，b+树，b*树的缺点与优点以及使用场景
ff_simon的博客
09-20 9948
1、二叉查找树的缺点 二叉查找树，相信大家都接触过，二叉查找树的特点就是左子树的节点值比父亲节点小，而右子树的节点值比父亲节点大，如图 基于二叉查找树的这种特点，我们在查找某个节点的时候，可以采取类似于二分查找的思想，快速找到某个节点。n 个节点的二叉查找树，正常的情况下，查找的时间复杂度为 O（logn）。 之所以说是正常情况下，是因为二叉查找树有可能出现一种极端的情况，例如 这种情况也是满...
二叉树的好处（应用）
热门推荐
zealot_2002的专栏
11-30 2万+
二叉排序树是一种比较有用的折衷方案。     数组的搜索比较方便，可以直接用下标，但删除或者插入某些元素就比较麻烦。     链表与之相反，删除和插入元素很快，但查找很慢。     二叉排序树就既有链表的好处，也有数组的好处。     在处理大批量的动态的数据是比较有用。   文件系统和数据库系统一般都采用树（特别是B树）的数据结构数据，主要为排序和检索的效率。二叉树是一种最基本最典型
线性表，二叉平衡树，散列表的优缺点
snowyuuu的博客
08-24 1974
对于优劣势，一方面考虑存储，一方面考虑性能： 线性表：可以用顺序表和链表实现，而且存储结构不一样，性能也不一样，总的来说线性表的优势是结构简单，访问节点比较快，对单节点的操作比较简单；适合于小数据量的存储，并且访问不存在经常变化的需求； 散列表：实现了随机访问，所以性能比较快，但是对于散列函数的设计要求比较高，而且设计需要根据自己的需求进行设计，实现高访问； 二叉平衡树：比较灵活，在空间上可...
实现平衡二叉树c语言编码,数据结构与算法 ：AVL平衡二叉树C语言实现
weixin_42696271的博客
05-19 125
C语言实现AVL平衡二叉树1结构体//这里定义一个取较大值的MAX宏#define MAX(a,b) ((a)>(b)?(a):(b))typedef struct AVLTreeNode {int data; //数据域int height; //数据域struct AVLTreeNode *left; //左子结点struct AVLTreeNode *right; //右子结点} AV...
平衡二叉树AVL操作模板
09-04
平衡二叉树 AVL 操作模板 平衡二叉树 AVL 操作模板是平衡二叉树的一种实现方式，通过 AVL 操作模板，可以对树进行插入、删除、查找等操作，并且保持树的平衡状态。 概念 1. 平衡二叉树：是一种自平衡二叉树，具有...
平衡二叉树 AVL
04-30
平衡二叉树（AVL树）是一种自平衡的二叉搜索树，由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL树。这种数据结构的主要特点是其左右子树的高度差不超过1，从而确保了搜索、插入和删除等操作的...
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
最新发布
02-10
平衡二叉树（Balanced Binary Tree）又被称为AVL树。具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。构造与调整方法。 实验目的： 二叉排序树的实现...
java-平衡二叉树AVL的实现
04-23
在Java编程领域，平衡二叉树（特别是AVL树）是一种高效的数据结构，它通过保持树的高度平衡来确保查找、插入和删除操作的最优化。AVL树是最早被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962...
数据结构——平衡二叉树（AVL树）（C语言实现）
sunshion_boy的博客
11-09 513
此程序是基于二叉搜索树下的平衡二叉树 我觉得大家对于二叉树不平衡时的四种情况，以及要怎么调整为平衡二叉树应该都是明白的，大家最疑惑的应该是运行程序时如何判断平衡因子不平衡。所以我在此着重讲解一下这个问题，此程序借助递归实现的，当插入的数据小于根节点的数据时，递归进入左子树，反之进入右子树，直到某一刻达到递归终止条件时，再往回返，所以可以根据返回来的时候可以根据确定此时处于在左子树还是右子树，再结合未修改之前的平衡因子判断该做出什么调整（注意插入数据后，往回返的时候才修改平衡因子，并且先判断是否做出调整，再修
有序平衡二叉树(AVL树)
07-23
一棵AVL树或者是空树，或者是具有下列性质的二叉搜索树：它的左子树和右子树都是AVL树，且左子树和右子树的高度之差的绝对值不超过1。
3.1 C语言_实现AVL平衡二叉树
Kim_小星兴的自留地
10-25 241
【序】 上节我们实现了数据结构中最简单的Vector，那么来到第三章，我们需要实现一个Set set的特点是 内部有序且有唯一元素值；同时各种操作的期望操作时间复杂度在O（n·logn）； 那么标准的C++ STL（Standard Template Library） 容器内部使用的是什么呢？ STL使用的是红黑树或者hash Tree ，由于笔者现在的水平和精力，没时间搞这个...
平衡二叉树
积累点滴，保持自我
11-11 2837
前言 上篇文章里面，我们已经学习了二叉搜索树的相关内容，二叉搜索树有一个缺点，在插入数据是有序的序列（包括升序和降序），会导致二叉树退化成链表，从而导致在查找，删除，添加时的性能均从O（logN）降低为O（N），这是不能接受的。如下图： 究其原因，是因为二叉搜索树退化成链表的时候，树的高度与节点的个数相等，也就是成正比，所以为了优化这种情况，就出现了具有平衡能力的二叉搜索树，其中AVL树是...
关于平衡二叉树的一些个人理解
InNoVaion_yu的博客
02-12 528
一、平衡二叉树的定义和概念： 平衡二叉树的概念基于先前学习的查找二叉树的概念。 之前提到过，由于查找二叉树存在建树或者删除节点顺序的的问题，会导致链式二叉树的存在。这样查找的时间复杂对就会变为O(n)。而为了让时间复杂度仍然保持O(logn)级别，所以加上了平衡的要求，这样的查找二叉树被称为平衡二叉树，英文缩写为AVL树； 二、平衡二叉树的数据结构： 平衡二叉树附加了一个平衡因子，用于衡量...
数据结构（十一）---平衡二叉树
weixin_44823875的博客
03-18 392
数据结构（十一）---平衡二叉树基本介绍创建节点类创建平衡二叉树测试类 基本介绍 （1）之前学习的是二叉排序树（BST），有优点也有缺点 优点：融合了数组和链表的优点，查找和插入删除的速度都很快 缺点：如果插入的是有序数列，那么二叉排序树就会失去平衡，退化成一个链表。 这样插入的速度不受影响，但是查询的速度大大降低 针对上面二叉排序树存在的不足，提出解决方案——平衡二叉树 （2）平衡二叉树基本介绍...
二叉树的优点和缺点
weixin_30895603的博客
04-28 4612
二叉树的优点和缺点 二叉排序树是一种比较有用的折衷方案。 数组的搜索比较方便，可以直接用下标，但删除或者插入某些元素就比较麻烦。 链表与之相反，删除和插入元素很快，但查找很慢。 二叉排序树就既有链表的好处，也有数组的好处。 在处理大批量的动态的数据是比较有用。 文件系统和数据库系统一般都采用树（特别是B树）的数据结...
判断树是否为平衡二叉树
Aiphis的博客
09-21 395
来自剑指offer 求树的深度 用递归做很简单，只要知道递归出口语句的别写错。 [cpp] view plaincopyprint? struct BinaryTreeNode   {       int m_Value;       BinaryTreeNode* m_pLeft;       BinaryTreeNode*
"数据结构实验报告：二叉排序树BST和平衡二叉树AVL构造
实验一 二叉树的应用：二叉排序树 BST 和平衡二叉树 AVL 的构造 一、实验学时：4 二、实验内容和目的： 树型结构是一类重要的非线性数据结构。其中以树和二叉树最为常用，直观看来，树是以分支关系定义的层次结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值