深入浅出C++ ——手撕AVL树

已于 2023-05-18 17:51:35 修改
阅读量802 收藏 2
点赞数
分类专栏： C++ 数据结构 文章标签： c++ 数据结构 AVL树 STL 树
于 2023-02-22 17:15:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55051736/article/details/127851186
版权

文章目录

前言

  在前面的文章中介绍了map / multimap / set / multiset 容器，这几个容器的底层都是按照二叉搜索树来实现的。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)。因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。

一、AVL 树介绍

  二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

  AVL树是一棵二叉搜索树，且高度平衡，因此AVL树也叫高度平衡二叉搜索树。如果AVL树有n个结点，其高度可保持在O(log_2 N)，搜索时间复杂度O(log_2 N)。

AVL树的性质

  • 任意一颗子树的左右子树都是AVL树。
  • 任意一颗子树的左右子树高度之差(简称平衡因子)的绝对值不超过1。

二、AVL树节点的定义

template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _bf(0)
	{}

	AVLTreeNode<K, V>* _left;	// 该节点的左孩子
	AVLTreeNode<K, V>* _right;	// 该节点的右孩子
	AVLTreeNode<K, V>* _parent;	// 该节点的双亲
	pair<K, V> _kv;			   // 该节点存储的kv值
	int _bf;				  // 该节点的平衡因子
};

三、AVL树的插入

AVL树的插入过程可以分为两步：

  1. 先按照二叉搜索树的规则将节点插入到AVL树中。
  2. 新节点插入后，AVL树的平衡性可能会遭到破坏，此时就需要更新平衡因子，并检测是否破坏了AVL树的平衡性。
bool Insert(const pair<K, V>& kv)
{
	if (_root == nullptr)
	{
		_root = new Node(kv);
		return true;
	}

	Node* parent = nullptr;
	Node* cur = _root;

	// 找插入节点的位置
	while (cur)
	{
		if (cur->_kv.first < kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_kv.first > kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}

	// 插入节点
	cur = new Node(kv);

	// 链接cur和parent
	if (parent->_kv.first < kv.first)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}

	cur->_parent = parent;

	// 控制平衡
	while (parent)	//最坏的情况是更新到根才会停止
	{
		// 更新平衡因子。新增在右，parent的平衡因子++ ；新增在左，parent的平衡因子--
		if (cur == parent->_right)
			parent->_bf++;
		else
			parent->_bf--;

		if (parent->_bf == 0)//更新后，parent的平衡因子为0，说明插入后两边一样高，插入填入了矮的部分，parent所在子树高度不变，不需要继续往上更新。
		{
			break;
		}
		else if (abs(parent->_bf) == 1)//更新后，abs(parent的平衡因子)为1，说明插入后有一边高，parent所在子树高度变了，需要继续往上更新。
		{
			parent = parent->_parent;
			cur = cur->_parent;
		}
		else if (abs(parent->_bf) == 2)//更新后，abs(parent的平衡因子)为2，说明已经打破平衡，parent所在子树需要旋转处理。
		{
			if (parent->_bf == 2 && cur->_bf == 1)
			{
				RotateL(parent);
			}
			else if ((parent->_bf == -2 && cur->_bf == -1))
			{
				RotateR(parent);
			}
			else if (parent->_bf == -2 && cur->_bf == 1)
			{
				RotateLR(parent);
			}
			else if (parent->_bf == 2 && cur->_bf == -1)
			{
				RotateRL(parent);
			}
			else
			{
				assert(false);
			}
			break;	//一次插入只会有一次旋转，旋转完成了直接break
		}
		else //更新后，abs(parent的平衡因子)大于2，说明插入前就不是AVL树，需要检查之前的操作
		{
			assert(false);
		}
	}
	return true;
}

四、AVL树的旋转

旋转原则：

  1. 旋转为平衡树
  2. 保持搜索树规则

新节点插入较高右子树的右侧—右右：左单旋

在这里插入图片描述

// 新节点插入较高右子树的右侧---右右：左单旋
void RotateL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;

	parent->_right = subRL;
	if (subRL)						//subRL可能为空
		subRL->_parent = parent;

	Node* ppNode = parent->_parent;  //注意：有可能parent不是根节点，保存上一层节点

	subR->_left = parent;
	parent->_parent = subR;

	if (_root == parent)			//parent是整棵树的根
	{
		_root = subR;
		subR->_parent = nullptr;
	}
	else                            //parent是子树的根
	{
		if (ppNode->_left == parent)//判断上一层节点和parent的关系
		{
			ppNode->_left = subR;
		}
		else
		{
			ppNode->_right = subR;
		}
		subR->_parent = ppNode;
	}

	subR->_bf = parent->_bf = 0;	//修改平衡因子
}

新节点插入较高左子树的左侧—左左：右单旋

在这里插入图片描述

// 新节点插入较高左子树的左侧---左左：右单旋
void RotateR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;

	parent->_left = subLR;
	if (subLR)
		subLR->_parent = parent;

	Node* ppNode = parent->_parent;

	subL->_right = parent;
	parent->_parent = subL;

	if (_root == parent)
	{
		_root = subL;
		subL->_parent = nullptr;
	}
	else
	{
		if (ppNode->_left == parent)
		{
			ppNode->_left = subL;
		}
		else
		{
			ppNode->_right = subL;
		}

		subL->_parent = ppNode;
	}

	subL->_bf = parent->_bf = 0;
}

新节点插入较高左子树的右侧—左右：先左单旋再右单旋

在这里插入图片描述

  在b或者c的位置插入，都会引起bf的变化，引发双旋。将双旋变成单旋后再旋转，即：先对30进行左单旋，然后再对90进行右单旋，旋转完成后再考虑平衡因子的更新。

在这里插入图片描述

// 新节点插入较高左子树的右侧---左右：先左单旋再右单旋
void RotateLR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	int bf = subLR->_bf;	//记录subLR的平衡因子，根据它的大小将其他平衡因子的更新分为三种情况

	RotateL(parent->_left); // 先cur左旋再parent右旋
	RotateR(parent);

	subLR->_bf = 0;
	if (bf == 1)			// c插入
	{
		parent->_bf = 0;
		subL->_bf = -1;
	}
	else if (bf == -1)		// b插入
	{
		parent->_bf = 1;
		subL->_bf = 0;
	}
	else if (bf == 0)		//a,b,c,d为空树，subLR为新增
	{
		parent->_bf = 0;
		subL->_bf = 0;
	}
	else					// 说明出问题了
	{
		assert(false);
	}
}

新节点插入较高右子树的左侧—右左：先右单旋再左单旋

整体思路同上：

//新节点插入较高右子树的左侧——右左：先右单旋再左单旋
void RotateRL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;

	int bf = subRL->_bf;

	RotateR(parent->_right);
	RotateL(parent);

	subRL->_bf = 0;
	if (bf == 1)
	{
		subR->_bf = 0;
		parent->_bf = -1;
	}
	else if (bf == -1)
	{
		subR->_bf = 1;
		parent->_bf = 0;
	}
	else if (bf == 0)
	{
		parent->_bf = 0;
		subR->_bf = 0;
	}
	else
	{
		assert(false);
	}
}

总结

  假如以Parent为根的子树不平衡，即Parent的平衡因子为2或者-2，分以下情况考虑：

  1. Parent的平衡因子为2，说明Parent的右子树高，设Parent的右子树的根为SubR。当SubR的平衡因子为1时，执行左单旋。当SubR的平衡因子为-1时，执行右左双旋。
  2. Parent的平衡因子为-2，说明Parent的左子树高，设Parent的左子树的根为SubL。当SubL的平衡因子为-1是，执行右单旋。当SubL的平衡因子为1时，执行左右双旋。

  旋转完成后，原Parent为根的子树个高度降低，已经平衡，不需要再向上更新。

旋转的意义

  1. 平衡
  2. 降高度

五、AVL树的验证

验证其为二叉搜索树

  如果中序遍历可得到一个有序的序列，就说明为二叉搜索树。

public:
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
	
		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}

验证其为平衡树

  每个节点子树高度差的绝对值不超过1，节点的平衡因子是否计算正确。

public：
	bool IsBalance()
	{
		return _IsBalance(_root);
	}
	
private:
	int Height(Node* root)
	{
		if (root == nullptr)
			return 0;
		return max(Height(root->_left), Height(root->_right)) + 1;
	} 
	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}
	
		int leftHT = Height(root->_left);
		int rightHT = Height(root->_right);
		int diff = rightHT - leftHT;
	
		if (diff != root->_bf)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}
	
		return abs(diff) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}

六、AVL树的删除

  因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不错与删除不同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。

七、AVL树的性能

  AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度为O(log_2 N)。

  但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。

  因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的，可以考虑AVL树，但一个结构经常修改，就不太适合。

八、AVL树的实现

#include<iostream>
#include<assert.h>
#include <map>
#include <string>
#include <algorithm>
#include<time.h>
#include <assert.h>
using namespace std;


template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _bf(0)
	{}

	AVLTreeNode<K, V>* _left;	// 该节点的左孩子
	AVLTreeNode<K, V>* _right;	// 该节点的右孩子
	AVLTreeNode<K, V>* _parent;	// 该节点的双亲

	pair<K, V> _kv;
	int _bf;					// 该节点的平衡因子
};

template<class K, class V>
struct AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;

		// 找插入节点的位置
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		// 插入节点
		cur = new Node(kv);

		// 链接cur和parent
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		cur->_parent = parent;

		// 控制平衡
		while (parent)	//最坏的情况是更新到根才会停止
		{
			// 更新平衡因子。新增在右，parent的平衡因子++ ；新增在左，parent的平衡因子--
			if (cur == parent->_right)
				parent->_bf++;
			else
				parent->_bf--;


			if (parent->_bf == 0)//更新后，parent的平衡因子为0，说明插入后两边一样高，插入填入了矮的部分，parent所在子树高度不变，不需要继续往上更新。
			{
				break;
			}
			else if (abs(parent->_bf) == 1)//更新后，abs(parent的平衡因子)为1，说明插入后有一边高，parent所在子树高度变了，需要继续往上更新。
			{
				parent = parent->_parent;
				cur = cur->_parent;
			}
			else if (abs(parent->_bf) == 2)//更新后，abs(parent的平衡因子)为2，说明已经打破平衡，parent所在子树需要旋转处理。
			{
				if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(parent);
				}
				else if ((parent->_bf == -2 && cur->_bf == -1))
				{
					RotateR(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				else
				{
					assert(false);
				}
				break;	//一次插入只会有一次旋转，旋转完成了直接break
			}
			else //更新后，abs(parent的平衡因子)大于2，说明插入前就不是AVL树，需要检查之前的操作
			{
				assert(false);
			}
		}
		return true;
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}
private:
	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}

		int leftHT = Height(root->_left);
		int rightHT = Height(root->_right);
		int diff = rightHT - leftHT;

		if (diff != root->_bf)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}

		return abs(diff) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}

	int Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		return max(Height(root->_left), Height(root->_right)) + 1;
	}

	// 新节点插入较高右子树的右侧---右右：左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)						//subRL可能为空
			subRL->_parent = parent;

		Node* ppNode = parent->_parent; //注意：有可能parent不是根节点，保存上一层节点

		subR->_left = parent;
		parent->_parent = subR;

		if (_root == parent)			//parent是整棵树的根
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else                            //parent是子树的根
		{
			if (ppNode->_left == parent)//判断上一层节点和parent的关系
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}

		subR->_bf = parent->_bf = 0;	//修改平衡因子
	}

	// 新节点插入较高左子树的左侧---左左：右单旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		Node* ppNode = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (_root == parent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}

			subL->_parent = ppNode;
		}

		subL->_bf = parent->_bf = 0;
	}

	// 新节点插入较高左子树的右侧---左右：先左单旋再右单旋
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;	//记录subLR的平衡因子，根据它的大小将其他平衡因子的更新分为三种情况

		RotateL(parent->_left); // 先cur左旋再parent右旋
		RotateR(parent);

		subLR->_bf = 0;
		if (bf == 1)			// c插入
		{
			parent->_bf = 0;
			subL->_bf = -1;
		}
		else if (bf == -1)		// b插入
		{
			parent->_bf = 1;
			subL->_bf = 0;
		}
		else if (bf == 0)		//a,b,c,d为空树，subLR为新增
		{
			parent->_bf = 0;
			subL->_bf = 0;
		}
		else					// 说明出问题了
		{
			assert(false);
		}
	}

	//新节点插入较高右子树的左侧——右左：先右单旋再左单旋
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		int bf = subRL->_bf;

		RotateR(parent->_right);
		RotateL(parent);

		subRL->_bf = 0;
		if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1)
		{
			subR->_bf = 1;
			parent->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}
private:
	Node* _root = nullptr;
};

void TestAVLTree1()
{
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };  // 测试双旋平衡因子调节
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	AVLTree<int, int> t1;
	for (auto e : a)
	{
		t1.Insert(make_pair(e, e));
	}
	t1.InOrder();
	cout << "IsBalance:" << t1.IsBalance() << endl;
}

void TestAVLTree2()
{
	size_t N = 10000;
	srand(time(0));
	AVLTree<int, int> t1;
	for (size_t i = 0; i < N; ++i)
	{
		int x = rand();
		t1.Insert(make_pair(x, i));
	}
	cout << "IsBalance:" << t1.IsBalance() << endl;
}
程序员丶Alex
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
手撕AVL树
GG_Bruse的博客
11-19 787
两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明AVL树
手撕AVL树-N*！！！
weixin_46571036的博客
08-15 108
二叉排序树的基础知识 名称：二叉排序树、二叉搜索树 性质： 1、左子树<根结点 2、右子树>根结点 用途：解决与排名相关的检索要求 构造二叉排序树： /* * @Author: mikey.peng * @Date: 2021-08-08 19:52:23 * @Last Modified by: mikey.peng * @Last Modified time: 2021-08-08 19:52:23 */ #include<iostream> #includ
C++手撕AVL树
分享学习的知识，记录我的技术成长道路
06-09 479
要手撕AVL树，我们首先要知道什么是AVL树。AVL树是在二叉搜索树的基础之上改造的。当我们插入的是一个有序的序列的时候，二叉搜素树会使用一条直线来进行存储，这样并不利于查找。 当遇到这种情况的时候我们就需要对这棵树来进行调整。AVL树会通过旋转等操作，来规避这种情况。最终满足每一个节点的平衡因子的绝对值......
手撕AVL树 (C++ 实现）
林慢慢的博客
06-29 942
AVL 树的定义、代码实现、性能分析
深入浅出C++ ——手撕红黑树
weixin_55051736的博客
02-22 553
/节点的值域 Colour _col;//节点的颜色 RBTreeNode < K , V > * _left;//节点的左孩子 RBTreeNode < K , V > * _right;//节点的右孩子 RBTreeNode < K , V > * _parent;//节点的双亲 };
c++后端相关(加深记忆，抄的github和小林coding)
weixin_44350672的博客
09-17 339
宏定义相当于字符替换，而const是常量声明；宏定义是预处理器处理，而const是编译器处理；宏定义五类型安全检查，而const有类型安全检查；宏定义不分配内存，const要分配内存；宏定义存在代码段，const存在数据段；析构函数设为私有，类生成对象就只能定义在堆上，因为c++是静态绑定语言，为类对象分配栈空间时，会先检查类析构函数的访问性，若析构函数不能访问就不能在栈上创建对象；第一阶段，使用 new 在堆上寻找可用内存，分配给对象；第二阶段，调用构造函数生成对象。
7.8.1 带你学习红黑树(1)
xutiantian1412的博客
08-13 278
继续学习二叉搜索树相关知识，我们来认识一下略高级的数据结构——红黑树。 鄙人在此仍然提供一些博客，并整理主要知识点及学习路线，由浅入深认识，觉得自己需要掌握到什么地步，适可而止。 红黑树的特点和主要性质 红黑树结点的插入和删除 由2-3-4树理解红黑树 python 手撕红黑树 推荐的文章又是July大神的系列文章，我会在下面的总结中捋一下怎么看： 1、教你透彻了解红黑树 2...
AVL树的c++实现
08-03
利用模板类以及智能指针shared_ptr写的关于AVL树的基本实现
AVL树 C++ 实现
03-05
平衡二叉树(AVL)的C++实现。 用泛型写的。 IDE为VS2008 好像没别的了~ 就怎么个东西
基于C++ AVL树的航空客运订票系统【100012693】
06-12
实现的功能分有七个模块：① 航班记录的录入 ② 航班数据的加载 ③ 航班记录的清除 ④ 航班的查询 ⑤ 航班的订票业务 ⑥ 航班的退票业务 ⑦ 航班数据的保存。
数据结构课程设计——基于Avl树的用户登陆系统.zip
09-29
1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，也适合...
C++平衡Avl树实现.zip
08-20
C++平衡树实现
C++：round函数用法
Solititude的博客
05-28 334
C++：round函数用法
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 811
string类各函数接口。
【如何在Qt C++中使用SSL和TLS加密传输数据？】
m0_45463480的博客
05-28 182
在这个示例中，我们创建了一个简单的Qt应用程序，向指定的HTTPS地址发送请求，并显示响应。信号来处理响应数据。您可以从响应中读取数据并进行进一步处理。来配置SSL/TLS连接，包括对证书进行验证和加密要求等。为您要访问的实际URL，并根据需要进一步配置SSL策略。在发送请求之前，可设置SSL配置。确保您的Qt项目已经链接了网络模块（对象发送网络请求，并接收响应。对象指定要访问的URL。
关于C++的特殊类定制
m0_62126248的博客
05-28 360
C++的一些特殊性质的类如何进行设计
C语言——指针
最新发布
weixin_45725380的博客
05-31 618
存储类型 数据类型 *指针变量名；例如：int *p;//定义了一个整数型指针变量pint a=5;int *p=&a;char b='v';char *q=&b;访问指针所指的空间里的内容时，需要用取内容运算符*来获取此时，变量p存放的就是a的地址，变量q存放的就是b的地址；符号*可以访问地址指向的空间里面的内容。指针与变量之间的关系如下：int i=3;本质还是指针，指向的是数组。（又称为行指针）所谓指针数组就是由若干个具有相同类型的指针变量组成的集合。
用C++代码写AVL树的旋转代码
03-13
以下是一个简单的C代码实现AVL树的旋转： //左旋转 AVLNode* leftRotate(AVLNode* node){ AVLNode* right = node->right; AVLNode* rightLeft = right->left; right->left = node; node->right = rightLeft; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员丶Alex

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值