AVL树原理剖析

最新推荐文章于 2023-05-01 17:06:42 发布
置顶 最新推荐文章于 2023-05-01 17:06:42 发布
阅读量298 收藏 1
点赞数 1
分类专栏： 容器自实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lpl312905509/article/details/103546369
版权

首先：
       问：什么树才叫AVL树？
       答：1、二叉查找树         2、平衡二叉树
那么什么树才叫二叉查找树
在这里插入图片描述
只要满足上图说的两个原则那他就是一个二叉查找树
       那么什么叫平衡二叉树？
在这里插入图片描述
只要满足上面两点那就是一颗AVL树

接下来开始上代码：
       1.数据结构的定义(本文采用模板T类型 为了更接近企业级代码)

template<typename T>
class Node
{
public:
	Node()
	{
	}
	inline operator T& ()
	{
		return data_;
	}

	T data_;
	int balance_; //AVL树的平衡因子(右节点的高度 - 左节点的高度)
	Node<T>* left_; //左节点
	Node<T>* right_;//右节点
	Node<T>* parent_;//父节点
};


template <typename T>
class AVLTree
{
public:
	AVLTree()
	{
		tree_ = NULL;
//		count_ = 0;
	}

	virtual ~AVLTree()
	{
		clear();
//		count_ = 0;
	}

	//清空AVLTree
	virtual void clear(Node<T>* node = NULL)
	{
		if (!node) node = tree_;

		if (!node) return;
		Node<T>* left = node->left_;
		Node<T>* right = node->right_;
		delete node;
		node = NULL;
		//这里还要去释放自己类内申请的内存
		{
			if (left)
				clear(left);
			if (right)
			clear(right);
		}
	}

	inline int height(Node<T>* node)
	{
		if (node == NULL)
		{
			return 0;
		}
		int rightheight = height(node->right_);
		int leftheight = height(node->left_);
		return rightheight > leftheight ? (rightheight + 1) : (leftheight + 1);
	}

	inline void setBalance(Node<T>* node)
	{
		if (node)
			node->balance_ = height(node->right_) - height(node->left_);
	}

	//查询操作 递归查询 未找到返回可以插入的根节点
	//const T& value 要查询的value
	//Node<T>* root 从哪个根节点开始查询 默认从根节点开始
	Node<T>* select(const T& value, Node<T>* root = NULL);

	//插入操作
	void insert(const T& value, Node<T>* root = NULL);

	//将节点右旋
	Node<T>* turnRight(Node<T>* node);

	//将节点左旋
	Node<T>* turnLeft(Node<T>* node);

	//先左旋再右旋
	Node<T>* turnLeftThenRight(Node<T>* node)
	{
		node->left_ = turnLeft(node->left_);
		return turnRight(node);
	}

	//先右旋再左旋
	Node<T>* turnRightThenLeft(Node<T>* node)
	{
		node->right_ = turnRight(node->right_);
		return turnLeft(node);
	}

	//获取该根节点上最小的节点
	inline Node<T>* getmin(Node<T>* node)
	{
		if (node->left_)
			getmin(node->left_);
		else
			return node;
	}

	//重新平衡node节点
	void rebalance(Node<T>* node);

	//删除节点  当该节点只有一个子节点或没有子节点
	void delnodeifhas1childornot(Node<T>* node);

	//删除该节点 且该节点有两个孩子节点
	void delnodeifhas2child(Node<T>* node);

	//删除node节点
	void del(const T& value, Node<T>* node);

private:
	Node<T>* tree_;  //AVL tree的树根
//	int count_;  //节点数
};

       2.节点的查询
在这里插入图片描述

//查询操作 递归查询 未找到返回可以插入的根节点
//const T& value 要查询的value
//Node<T>* root 从哪个根节点开始查询 默认从根节点开始
Node<T>* select(const T& value, Node<T>* root = NULL)
{
	if (!root) root = tree_;
	if (!root) return NULL;

	if (root->data_ == value) //找到该节点
		return root;
	else if (root->data_ > value) //
	{
		if (root->left_)
			return select(value, root->left_); //继续到左子节点查询
		else
			return root; //返回根节点
	}
	else if (root->data_ < value)
	{
		if (root->right_)
			return select(value, root->right_); //继续到右子节点查询
		else
			return root;//返回根节点
	}

	return NULL;
}

       3.节点的插入
在这里插入图片描述扩展:讲到二叉树失衡,那就要讲解二叉树失衡的方式以及如何解决二叉树失衡
二叉树失衡的4种情形:
在这里插入图片描述上图介绍了两种只需要进行一次旋转就能使二叉树重新达到平衡的情形
在这里插入图片描述上图介绍了两种需要进行两次旋转就能使二叉树重新达到平衡的情形

结论:
1.当根节点平衡因子 = -2 ,且与左子节点的平衡因子符号相同,则需要右旋
2.当根节点平衡因子 = 2,且与右子节点的平衡因子符号相同,则需要左旋
3.当根节点平衡因子 = -2 ,且与左子节点的平衡因子符号不一致时,则需要先右旋后左旋
4.当根节点平衡因子 = 2 ,且与右子节点的平衡因子符号不一致时,则需要先左旋后右旋

	//将节点右旋
	Node<T>* turnRight(Node<T>* node)
	{
		// 右旋使node的父节点的子节点替换为b
		Node<T>* b = node->left_;
		if (node->parent_ != NULL) {
			if (node->parent_->right_ == node)
			{
				node->parent_->right_ = b;
			}
			else
			{
				node->parent_->left_ = b;
			}
		}
		b->parent_ = node->parent_;
		//将b的右子树作为a的左子树，并将a作为b的右子树
		node->parent_ = b;
		node->left_ = b->right_;
		if (node->left_ != NULL)
			node->left_->parent_ = node;
		b->right_ = node;
		//重新设置a、b节点的balance值
		setBalance(node);
		setBalance(b);
		//返回b节点
		return b;
	}

//将节点左旋
	Node<T>* turnLeft(Node<T>* node)
	{
		//左旋把node的父节点的子节点替换为b
		Node<T>* b = node->right_;
		if (node->parent_ != NULL) {
			if (node->parent_->right_ == node) {
				node->parent_->right_ = b;
			}
			else {
				node->parent_->left_ = b;
			}
		}
		b->parent_ = node->parent_;
		//将node作为b的左子树，并将b的左子树作为node的右子树
		node->parent_ = b;
		node->right_ = b->left_;
		b->left_ = node;
		if (node->right_ != NULL)
			node->right_->parent_ = node;
		//重新设置node、b的balance值
		setBalance(node);
		setBalance(b);
		//返回b节点
		return b;
	}

//插入操作
	void insert(const T& value, Node<T>* root = NULL)
	{
		if (!root) root = tree_;

		Node<T>* node = select(value, root);

		if (node == NULL) //为空 代表tree为空
		{
			tree_ = new Node<T>;
			tree_->data_ = value;
			tree_->left_ = tree_->right_ = NULL;
			tree_->parent_ = NULL;
			tree_->balance_ = 0;
		}
		else if (node->data_ != value)
		{
			Node<T>* newNode = new Node<T>;
			newNode->data_ = value;
			newNode->right_ = newNode->left_ = NULL;
			newNode->parent_ = node;
			newNode->balance_ = 0;

			if (node->data_ > value) //新增节点比跟节点小 则查到根节点的左节点上
			{
				node->left_ = newNode;
			}
			else if (node->data_ < value)//新增节点比跟节点大 则查到根节点的右节点上
			{
				node->right_ = newNode;
			}

			rebalance(node);
		}
	}

       4.节点的删除
![在这里插入图片描述](https://img-blog.csdnimg.cn/2019121523261340.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xwbDMxMjkwNTUwOQ==,size_16,color_FFFFFF,t_70
在这里插入图片描述//接下来上节点删除的代码

	//重新平衡node节点
	void rebalance(Node<T>* node)
	{
		setBalance(node);
		if (node->balance_ == -2) {
			if (node->left_->balance_ <= 0) //符号相同
			{
				node = turnRight(node); //右旋
			}
			else  //符号不同 需要两次旋转
			{
				node = turnLeftThenRight(node);
			}
		}
		else if (node->balance_ == 2)
		{
			if (node->right_->balance_ >= 0)//符号相同
			{
				node = turnLeft(node);
			}
			else//符号不同 需要两次旋转
			{
				node = turnRightThenLeft(node);
			}
		}
		if (node->parent_)
		{
			rebalance(node->parent_);
		}
		else
		{
			tree_ = node;
		}
	}

	//删除节点  当该节点只有一个子节点或没有子节点
	void delnodeifhas1childornot(Node<T>* node)
	{
		if (!node) return;
		if (node->parent_ == NULL)
		{
			if (node->left_)
			{
				tree_ = node->left_;
				node->left_->parent_ = NULL;
			}
			else
			{
				tree_ = node->right_;
				node->right_->parent_ = NULL;
			}
		}
		else
		{
			if (node->parent_->left_ == node)
			{
				if (node->left_)
				{
					node->parent_->left_ = node->left_;
					node->left_->parent_ = node->parent_;
				}
				else
				{
					node->parent_->left_ = node->right_;
					if (node->right_)
						node->right_->parent_ = node->parent_;
				}
			}
			else
			{
				if (node->left_)
				{
					node->parent_->right_ = node->left_;
					node->left_->parent_ = node->parent_;
				}
				else
				{
					node->parent_->right_ = node->right_;
					if (node->right_)
						node->right_->parent_ = node->parent_;
				}
			}
			rebalance(node->parent_);
		}
		delete node;
		node = NULL;
	}

	//删除该节点 且该节点有两个孩子节点
	void delnodeifhas2child(Node<T>* node)
	{
		Node<T>* after = getmin(node->right_);
		node->data_ = after->value;
		delnodeifhas1childornot(after);
	}

	//删除node节点
	void del(const T& value, Node<T>* node)
	{
		Node<T>* node = select(value, root);
		if (node->data_ == value)
		{
			if (node->left_ && node->right_) {
				delnodeifhas2child(node);
			}
			else
			{
				delnodeifhas1childornot(node);
			}
		}
	}

算是完整讲解完了AVL树的原理,恐怕还是有疏漏之处,请大牛们不吝赐教,如有问题或疑问,请加群641792143交流与学习,避免闭门造车

下面贴出完整代码:

#include <assert.h>
#include <iostream>

using namespace  std;

template<typename T>
class Node
{
public:
	Node()
	{
	}
	inline operator T& ()
	{
		return data_;
	}

	T data_;
	int balance_; //AVL树的平衡因子(右节点的高度 - 左节点的高度)
	Node<T>* left_; //左节点
	Node<T>* right_;//右节点
	Node<T>* parent_;//父节点
};


template <typename T>
class AVLTree
{
public:
	AVLTree()
	{
		tree_ = NULL;
		count_ = 0;
	}

	virtual ~AVLTree()
	{
		clear();
		count_ = 0;
	}

	//清空AVLTree
	virtual void clear(Node<T>* node = NULL)
	{
		if (!node) node = tree_;

		if (!node) return;
		Node<T>* left = node->left_;
		Node<T>* right = node->right_;
		delete node;
		node = NULL;
		//这里还要去释放自己类内申请的内存
		{
			if (left)
				clear(left);
			if (right)
			clear(right);
		}
	}

	inline int height(Node<T>* node)
	{
		if (node == NULL)
		{
			return 0;
		}
		int rightheight = height(node->right_);
		int leftheight = height(node->left_);
		return rightheight > leftheight ? (rightheight + 1) : (leftheight + 1);
	}

	inline void setBalance(Node<T>* node)
	{
		if (node)
			node->balance_ = height(node->right_) - height(node->left_);
	}

	//查询操作 递归查询 未找到返回可以插入的根节点
	//const T& value 要查询的value
	//Node<T>* root 从哪个根节点开始查询 默认从根节点开始
	Node<T>* select(const T& value, Node<T>* root = NULL)
	{
		if (!root) root = tree_;

		if (!root) return NULL;

		if (root->data_ == value) //找到该节点
			return root;
		else if (root->data_ > value) //
		{
			if (root->left_)
				return select(value, root->left_); //继续到左子节点查询
			else
				return root; //返回根节点
		}
		else if (root->data_ < value)
		{
			if (root->right_)
				return select(value, root->right_); //继续到右子节点查询
			else
				return root;//返回根节点
		}

		return NULL;
	}

	//插入操作
	void insert(const T& value, Node<T>* root = NULL)
	{
		if (!root) root = tree_;

		Node<T>* node = select(value, root);

		if (node == NULL) //为空 代表tree为空
		{
			tree_ = new Node<T>;
			tree_->data_ = value;
			tree_->left_ = tree_->right_ = NULL;
			tree_->parent_ = NULL;
			tree_->balance_ = 0;
		}
		else if (node->data_ != value)
		{
			Node<T>* newNode = new Node<T>;
			newNode->data_ = value;
			newNode->right_ = newNode->left_ = NULL;
			newNode->parent_ = node;
			newNode->balance_ = 0;

			if (node->data_ > value) //新增节点比跟节点小 则查到根节点的左节点上
			{
				node->left_ = newNode;
			}
			else if (node->data_ < value)//新增节点比跟节点大 则查到根节点的右节点上
			{
				node->right_ = newNode;
			}

			rebalance(node);
		}
	}

	//将节点右旋
	Node<T>* turnRight(Node<T>* node)
	{
		// 右旋使node的父节点的子节点替换为b
		Node<T>* b = node->left_;
		if (node->parent_ != NULL) {
			if (node->parent_->right_ == node)
			{
				node->parent_->right_ = b;
			}
			else
			{
				node->parent_->left_ = b;
			}
		}
		b->parent_ = node->parent_;
		//将b的右子树作为a的左子树，并将a作为b的右子树
		node->parent_ = b;
		node->left_ = b->right_;
		if (node->left_ != NULL)
			node->left_->parent_ = node;
		b->right_ = node;
		//重新设置a、b节点的balance值
		setBalance(node);
		setBalance(b);
		//返回b节点
		return b;
	}

	//将节点左旋
	Node<T>* turnLeft(Node<T>* node)
	{
		//左旋把node的父节点的子节点替换为b
		Node<T>* b = node->right_;
		if (node->parent_ != NULL) {
			if (node->parent_->right_ == node) {
				node->parent_->right_ = b;
			}
			else {
				node->parent_->left_ = b;
			}
		}
		b->parent_ = node->parent_;
		//将node作为b的左子树，并将b的左子树作为node的右子树
		node->parent_ = b;
		node->right_ = b->left_;
		b->left_ = node;
		if (node->right_ != NULL)
			node->right_->parent_ = node;
		//重新设置node、b的balance值
		setBalance(node);
		setBalance(b);
		//返回b节点
		return b;
	}

	//先左旋再右旋
	Node<T>* turnLeftThenRight(Node<T>* node)
	{
		node->left_ = turnLeft(node->left_);
		return turnRight(node);
	}

	//先右旋再左旋
	Node<T>* turnRightThenLeft(Node<T>* node)
	{
		node->right_ = turnRight(node->right_);
		return turnLeft(node);
	}

	//获取该根节点上最小的节点
	inline Node<T>* getmin(Node<T>* node)
	{
		if (node->left_)
			getmin(node->left_);
		else
			return node;
	}

	//重新平衡node节点
	void rebalance(Node<T>* node)
	{
		setBalance(node);
		if (node->balance_ == -2) {
			if (node->left_->balance_ <= 0) //符号相同
			{
				node = turnRight(node); //右旋
			}
			else  //符号不同 需要两次旋转
			{
				node = turnLeftThenRight(node);
			}
		}
		else if (node->balance_ == 2)
		{
			if (node->right_->balance_ >= 0)//符号相同
			{
				node = turnLeft(node);
			}
			else//符号不同 需要两次旋转
			{
				node = turnRightThenLeft(node);
			}
		}
		if (node->parent_)
		{
			rebalance(node->parent_);
		}
		else
		{
			tree_ = node;
		}
	}

	//删除节点  当该节点只有一个子节点或没有子节点
	void delnodeifhas1childornot(Node<T>* node)
	{
		if (!node) return;
		if (node->parent_ == NULL)
		{
			if (node->left_)
			{
				tree_ = node->left_;
				node->left_->parent_ = NULL;
			}
			else
			{
				tree_ = node->right_;
				node->right_->parent_ = NULL;
			}
		}
		else
		{
			if (node->parent_->left_ == node)
			{
				if (node->left_)
				{
					node->parent_->left_ = node->left_;
					node->left_->parent_ = node->parent_;
				}
				else
				{
					node->parent_->left_ = node->right_;
					if (node->right_)
						node->right_->parent_ = node->parent_;
				}
			}
			else
			{
				if (node->left_)
				{
					node->parent_->right_ = node->left_;
					node->left_->parent_ = node->parent_;
				}
				else
				{
					node->parent_->right_ = node->right_;
					if (node->right_)
						node->right_->parent_ = node->parent_;
				}
			}
			rebalance(node->parent_);
		}
		delete node;
		node = NULL;
	}

	//删除该节点 且该节点有两个孩子节点
	void delnodeifhas2child(Node<T>* node)
	{
		Node<T>* after = getmin(node->right_);
		node->data_ = after->value;
		delnodeifhas1childornot(after);
	}

	//删除node节点
	void del(const T& value, Node<T>* node)
	{
		Node<T>* node = select(value, root);
		if (node->data_ == value)
		{
			if (node->left_ && node->right_) {
				delnodeifhas2child(node);
			}
			else
			{
				delnodeifhas1childornot(node);
			}
		}
	}

private:
	Node<T>* tree_;  //AVL tree的树根
	int count_;  //节点数
};



int main()
{
	{
		AVLTree<int> avlTree;
		avlTree.insert(5);
		avlTree.insert(6);
		avlTree.insert(7);
	}
	

	system("pause");
	return 0;
}
lpl312905509
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
avl.rar_AVL树
09-19
AVL树是一种自平衡二叉查找树（Self-Balancing Binary Search Tree，简称SBT），由G. M. Adelson-Velsky和E. M. Landis在1962年提出，...通过理解和实现这些操作，我们可以掌握AVL树的工作原理及其在实际问题中的应用。
AVL树原理
qq_55996124的博客
09-04 303
特征 AVL树是 平衡 && 搜索 && 二叉树 1. 搜索树 中序遍历一定是有序的，并且按照key的大小顺序排列 任取节点，left.key < root.key < right.key 2. AVL树中平衡的定义 任取节点，要求 节点左子树的高度 和 节点右子树的高度 的高度差的绝对值不能超过 1 平衡因子(Balance Factor / BF)： bf就是节点的左右子树高度差，node.BF= H(node.left) - H(..
AVL树的原理和代码实现（图文并茂）
最新发布
qq_56166591的博客
05-01 166
重点讲解AVL树的实现原理和代码
AVL树原理详解与实现（附代码）
热门推荐
张凯
08-15 1万+
上一篇文章讲了二叉搜索树，但是它会在极端情况下退化为链表，造成查找时间复杂度退化为O(N)O(N)O(N)，那么怎样才能让它不退化为链表呢？这篇文章告诉你，快来看看把！ 文章目录1. 平衡二叉树的定义2. AVL树的调整3. AVL树的实现4. 完整代码，带测试程序 1. 平衡二叉树的定义 平衡说的是树的高度平衡，平衡二叉树可以这么定义： 一颗空树 如果不是空树，那么它的左子树和右子树都是平衡二叉树，且左右子树的高度差绝对值不超过1 树的高度怎么定义？ 如果是空树，高度为0 如果不是空树，那高度就.
AVL 树
sqjddb的博客
03-10 385
一、AVL树的由来及概念 二、AVL树的原理（旋转） 三、AVL树的实现 四、AVL树的性能
AVL树详解
夜槿笙歌的博客
06-05 5497
二叉搜索树有了经典的二叉搜索树做铺垫，我们就可以正式开始讲解由它衍生出的几种改进的二叉搜索树结构。首先是AVL树，也就是我们常说的平衡二叉树。从名字就可以看出，AVL树是一种高度平衡的二叉搜索树，即任意节点的左子树和右子树高度之差都不超过1。那么我们为什么要让一棵二叉搜索树尽量平衡呢？我们假设现在有一组输入数据[1,2,3,4,5]，按照先前的插入逻辑，就会形成如下结构的二叉树：这棵树的高度和它的元素个数是一致的，因为二叉搜索树各种操作所消耗的时间与其高度密切相关，因此这棵树所形成的的结构显然不是我们想看到
avl.rar_AVL树_树
09-23
在提供的"avl.rar"压缩包中，包含了关于AVL树的分析和源码，可以帮助我们更深入地理解和实现AVL树的相关操作，如左旋、右旋以及树的平衡调整。通过学习这些内容，我们可以掌握AVL树的基本原理，进一步提升在数据结构...
AVL.rar_AVL树_avl_avl树源代码
09-14
AVL树是一种自平衡二叉查找树（Binary Search Tree，BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此...理解和掌握AVL树的原理和操作，对于提升算法能力，优化数据存储和检索的效率有着显著的作用。
avl.zip_1到n的avl图_avl树插入数字
09-21
AVL树是一种自平衡二叉查找树（Self-Balancing Binary Search Tree），由G. M. Adelson-Velsky和E. M. Landis在1962年提出，...通过分析从1到N的数字插入AVL树后的遍历结果，我们可以更好地掌握AVL树的特性和操作原理。
数据结构-用户登录实验-二叉查找树AVL树实现
05-23
本实验专注于二叉查找树（Binary Search Tree, BST）以及它的平衡版本——AVL树。这两种数据结构在处理大量数据时，尤其是进行查找、插入和删除操作时，具有较高的效率。 首先，二叉查找树是一种特殊的二叉树，其中...
AVL树算法的动态演示的设计与实现.pdf
04-03
《数据结构》 是计算机学科中一门十分重要的核心课程， 而对于算法的理解则是学好该课程的关键。为了使学生更好的理解算法， 作为对课堂教学的有益补充， 我们设计开发了 《AVL树算法的动态演示》 ， 以帮助学生理解数据结构算法。本文通过对这种交互式动态演示的设计实现过程的详细描述， 着重讨论了 AVL树动态演示的算法实现。
AVL树（平衡二叉树）的底层原理以及实现
荣耀与梦想来日方长
03-11 1242
前言 Wiki:在计算机科学中，AVL树是最早被发明的自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下的时间复杂度都是{\displaystyle O(\log {n})} 。增加和删除元素的操作则可能需要借由一次或多次树旋转，以实现树的重新平衡。AVL 树得名于它的发明者G. M. Adelson-Velsky和Evgenii Landis，他们在1962年的论文《An algorithm for the org...
[ 数据结构 - C++] AVL树原理及实现
CSDN博客
09-26 1022
平衡二叉搜索树-- AVL树 C++实现
AVL树原理通俗解释与例子
小松鼠的专栏
04-21 3108
AVL（Adelson-Velskii and Landis）树是带有平衡条件（balance condition）的二叉查找树。 这个平衡条件必须容易保持，而且必须保证树的深度是O(logN)。 AVL树规定其每个结点的左子树和右子树的高度最多差1。 BF(Balance Factor) = 二叉树上结点的左子树深度 - 右子树的深度。 平衡二叉树上的结点的BF值只能是1 -1 0，只要有一个结
AVL树的原理及代码实现
qq_39747794的博客
11-02 1154
前言 如果你还没有学习过二叉查找树，那么请你先去看看二叉查找树，因为AVL树便是从二叉查找树进化而来的，不看的话你无法理解AVL树。 链接：二叉查找树的原理及实现 如果你已经学习了二叉查找树，你会觉得二叉查找树性能在各方面都很好，就只有一丢丢的小毛病，那就是当数据非常坑时，二叉查找树退化成了一条单链表，这样各种操作的时间复杂度都变为O(n)了，怎么办呢，今天所要学习的AVL树便以其惊艳四座的...
AVL树原理思想及其实现
sunjunior的专栏
07-05 741
AVL树，一种平衡搜索二叉树，是BST(Binary Search Tree)二叉查找树的一种，实际上是在BST搜索树上增加了平衡条件，所谓的平衡条件指的是树中的每个结点的左孩子与右孩子的高度之差不大于1。既然是一种BST树，那么它肯定满足BST的一般性质。在计算机科学领域，二叉搜索树(BST),有时也称作有序的或者排序好的二叉树，是一种特殊类型的容器。它允许快速的查找，增加，删除结点，可以被用作
AVL树原理理解：旋转与平衡
angrypop的博客
09-14 1552
二叉查找树原理理解：进阶与平衡 1.大危机 假如要构建BST的数组本身是严格递增的… 查找树会退化成一条链，构造将毫无意义。 2.平衡
数据结构&&AVL树原理、插入操作详解及实现
sp_programmer的专栏
12-08 5544
AVL树原理、插入数据原理、实现。
AVLTreeMap
Go的全部
11-14 1246
package SortedMap import "testing" type KEY interface { CompareTo(v KEY) int } type VALUE interface{} type AVLNode struct { K KEY V VALUE L *AVLNode R *AVLNode H int } func NewAVLNode(key KEY, value VALUE) *AVLNode { return &AVLNode{ K: k
AVL树与红黑树详解：动态平衡插入与删除操作
本资源PPT详细介绍了AVL树和红黑树的工作原理及其动态平衡机制。 首先，我们来看AVL树。AVL树是一种严格平衡的二叉搜索树，其特点是每个节点的两个子树的高度差最多为1。在AVL树中，每个节点都定义了一个“平衡因子...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值