数据结构之AVL树（万字详解）

最新推荐文章于 2024-09-29 22:26:41 发布
最新推荐文章于 2024-09-29 22:26:41 发布
阅读量875 收藏 7
点赞数 13
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/paradiso989/article/details/142628879
版权

目录

一、什么是AVL树

1.1 AVL树介绍

1.2 AVL树的结构

二、AVL树的插入

2.1 插入过程

2.2 更新平衡因子 

三、AVL树的旋转

3.1 单旋思路

3.2 单旋代码

3.3 为什么要双旋

3.4 双旋思路

3.5 双旋代码

四、C++源代码

一、什么是AVL树

1.1 AVL树介绍

  • AVL树是一种自平衡的二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis在1962年提出。
  • AVL树是最先发明的⾃平衡⼆叉查找树，AVL树是⼀颗⾼度平衡搜索⼆叉树，通过控制⾼度差去控制平衡。
  • AVL树整体结点数量和分布和完全⼆叉树类似，⾼度可以控制在 logN，那么增删查改的效率也可以控制在O(logN)，相⽐⼆叉搜索树有了本质的提升。

AVL树支持常见的二叉搜索树操作，如插入、删除和搜索

  • 插入：在AVL树中插入节点时，可能会破坏树的平衡性。为了恢复平衡，需要进行一次或多次旋转操作。根据节点平衡因子的不同，可能需要进行单旋（左旋或右旋）或双旋（先左后右或先右后左）。
  • 删除：删除节点时同样可能破坏树的平衡性。通过旋转操作（可能包括单旋和双旋）来恢复平衡。
  • 搜索：在AVL树中搜索节点的过程与在普通二叉搜索树中相同，但由于AVL树的高度始终保持在O(log n)，因此搜索操作的时间复杂度也是O(log n)。

本文重点讲解插入旋转操作，与搜索二叉树重合的部分详见：数据结构之搜索二叉树-CSDN博客

1.2 AVL树的结构

  1. 二叉搜索树特性：左子树中所有节点的值小于根节点的值，右子树中所有节点的值大于根节点的值，且左右子树也分别是AVL树。
  2. 高度平衡：对于任意节点，其左右子树的高度差的绝对值不超过1。
  3. 平衡因子：每个节点都有一个平衡因子，定义为该节点的左子树高度减去右子树高度的差值。在AVL树中，平衡因子的值只能是0、1或-1（不平衡就要进行旋转操作）。
  4. 三叉链：三叉链结构在AVL树中指的是每个节点不仅包含指向左右子节点的指针，还包含一个指向其父节点的指针（即_parent）。这种结构使得节点能够直接访问其父节点，从而在进行插入、删除等操作时能够更高效地向上回溯和更新平衡因子。
template<class K, class V>
struct AVLTreeNode
{
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	// 需要parent 指针，使得更新平衡因⼦可以向上更新
	AVLTreeNode<K, V>* _parent;

	int _bf;	//平衡因子-balance factor

	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)             //新增的节点平衡因子一定为0
	{}
};

二、AVL树的插入

2.1 插入过程

  1. 插⼊⼀个值按⼆叉搜索树规则进⾏插⼊。
  2. 更新平衡因子没有问题则结束
  3. 更新平衡因子出现不平衡，则旋转
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);
	//正确插入
	if (parent->_kv.first < kv.first)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	//链接父亲
	cur->_parent = parent;

	// 更新平衡因⼦
    ......
}

2.2 更新平衡因子 

什么时候更新：

  1. 只有⼦树⾼度变化才会影响当前结点平衡因⼦。
  2. 插入在parent节点的右子树，平衡因子++；插入在parent节点的左子树，平衡因子--。
  3. parent的子树高度变化需要向上更新。

什么时候停止更新：

  1. 更新后parent的平衡因⼦等于0：说明平衡因子是由-1/1->0变化的，也就说明插入前一边高一边低，插入后左右一样高。整体子树的高度不变，无需向上更新。
  2. 更新后parent的平衡因⼦等于1 或 -1：说明平衡因子是由0->1/-1变化的，也就说明插入前一样高，插入后一边高一边低。整体子树高度++，需要向上更新。
  3. 更新后parent的平衡因⼦等于2 或 -2：说明平衡因子是由1->2/-1->-2变化的，也就说明插入前一边高一边低，新节点插入在高的一边，插入后不符合AVL树的规则，需要进行旋转处理
// 更新平衡因⼦
while (parent)          //向上更新
{
	// 先更新平衡因⼦
	if (cur == parent->_left)
	{
		parent->_bf--;
	}
	else
	{
		parent->_bf++;
	}
	//结束条件
	if (parent->_bf == 0)
	{
		// 更新结束
		break;
	}
	else if (parent->_bf == 1 || parent->_bf == -1)
	{
		// 继续往上更新
		cur = parent;
		parent = parent->_parent;
	}
	else if (parent->_bf == 2 || parent->_bf == -2)
	{
		// 不平衡了，旋转处理
		......
	}
	else
	{
		assert(false);
	}
}

三、AVL树的旋转

3.1 单旋思路

以左单旋为例讲解，右单旋类比左单旋即可。

  1. 图中表示的树是广义上的抽象的树：既可以代表整棵树也可以代表其中一颗子树。模糊掉了子树的节点组成，仅关注的是不平衡的节点
  2. 旋转核心：b树的根节点值介于6和9之间，旋转是将b作为6的右子树，6作为9的左子树。从而实现整体高度的降低 

3.2 单旋代码

根据上述图示，生成基本的代码

void RotateL(Node* parent)
{
    Node* subR = parent->_right;
    Node* subRL = subR->_left;
    subR->_left = parent;
    parent->_parent = subR;
}

但是，旋转实际上会破坏原来的三叉链的结构，旋转后的平衡因子也需要更新。所以进一步完善代码。

三叉链更新：

  1. 如果subRL也就是图中的b树为空，subRL没有父亲指针，不需要更新。只有在subRL不为空时，才需要将subRL的_parent->parent。
  2. 如果parent是整棵树的根节点：那么旋转后新的节点为subR，subR的_parent->nullptr
  3. 如果parent不是整棵树的根节点：那么subR的_parent就要指向原来parent的parent。

平衡因子更新：

        由图示可知，旋转后只有parent和subR的平衡因子发生变化，且都变为0

//左旋源代码
void RotateL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;

	parent->_right = subRL;
	if (subRL)
		subRL->_parent = parent;

	Node* Pparent = parent->_parent;

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

	/*调整旋转后树的结构符合树的基本原则*/
	//1.整棵树的根
	if (parent==_root)
	{
		_root = subR;
		subR->_parent = nullptr;
	}
	else
	{
		if (Pparent->_left == parent)
		{
			Pparent->_left = subR;
		}
		else
		{
			Pparent->_right = subR;
		}
		subR->_parent = Pparent;
	}

	//更新平衡因子
	subR->_bf = 0;
	parent->_bf = 0;
}

//右旋源代码
void RotateR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;

	parent->_left = subLR;
	//细节
	if(subLR)
		subLR->_parent = parent; 

	//保存父亲节点便于后续操作
	Node* Pparent = parent->_parent;

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

	/*调整旋转后树的结构符合树的基本原则*/
	//1.整棵树的根
	if (parent == _root)
	{
		_root = subL;
		subL->_parent = nullptr;
	}
	//2.局部子树的根
	else
	{
		if (Pparent->_left == parent)
		{
			Pparent->_left = subL;
		}
		else
		{
			Pparent->_right = subL;
		}
		subL->_parent = Pparent;
	}

	//更新平衡因子
	subL->_bf = 0;
	parent->_bf = 0;
}

3.3 为什么要双旋

单旋的情况我们只考虑了左边高插在子树的左边/右边高插在子树的右边。那么左边高插在子树的右边还能否用单旋的思路解决？

很明显，采用单旋的思路是错误的。

 

双旋才能解决此类问题 

3.4 双旋思路

以先右旋再左旋为例进行分析，先左旋后右旋类比即可。

上述图已经展示了双旋的基本思路，但是双旋的难点还在于平衡因子的更新。需要分为三种情况进行分析：

  1. 插在x子树，parent的平衡因子=0，subR的平衡因子=1，subRL的平衡因子=0。
  2. 插在y子树，parent的平衡因子=-1.subR的平衡因子=0，subRL的平衡因子=0。
  3. h == 0时，a/x/y/c都是空树，旋转后平衡因子都为0。

3.5 双旋代码

由上述思路可知：需要保存subRL的平衡因子作为判断情况1，2，3的依据

//先右后左
void RotateRL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	int bf = subRL->_bf;

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

	//更新平衡因子
	if (bf == -1)
	{
		subRL->_bf = 0;
		subR->_bf = 1;
		parent->_bf = 0;
	}
	else if (bf == 1)
	{
		subRL->_bf = 0;
		subR->_bf = 0;
		parent->_bf = -1;
	}
	else if (bf == 0)
	{
		subRL->_bf = 0;
		subR->_bf = 0;
		parent->_bf = 0;
	}
	else
	{
		assert(false);
	}

}
//先左后右
void RotateLR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	int bf = subLR->_bf;
	
	RotateL(parent->_left);
	RotateR(parent);

	//更新平衡因子
	if (bf == -1)
	{
		subLR->_bf = 0;
		subL->_bf = 0;
		parent->_bf = 1;
	}
	else if (bf == 1)
	{
		subLR->_bf = 0;
		subL->_bf = -1;
		parent->_bf = 0;
	}
	else if (bf == 0)
	{
		subLR->_bf = 0;
		subL->_bf = 0;
		parent->_bf = 0;
	}
	else
	{
		assert(false);
	}
}

四、C++源代码

源代码：AVL.h

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

using namespace std;

template<class K, class V>
struct AVLTreeNode
{
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	// 需要parent 指针，使得更新平衡因⼦可以向上更新
	AVLTreeNode<K, V>* _parent;

	int _bf;	//平衡因子-balance factor

	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)             //新增的节点平衡因子一定为0
	{}
};

template<class K, class V>
class 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);
		//正确插入
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		//链接父亲
		cur->_parent = parent;

		// 更新平衡因⼦
		while (parent)          //向上更新
		{
			// 先更新平衡因⼦
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}
			//结束条件
			if (parent->_bf == 0)
			{
				// 更新结束
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				// 继续往上更新
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				// 不平衡了，旋转处理
				if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(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;
			}
			else
			{
				assert(false);
			}
		}

		return true;
	}
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		//细节
		if(subLR)
			subLR->_parent = parent; 

		//保存父亲节点便于后续操作
		Node* Pparent = parent->_parent;

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

		/*调整旋转后树的结构符合树的基本原则*/
		//1.整棵树的根
		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		//2.局部子树的根
		else
		{
			if (Pparent->_left == parent)
			{
				Pparent->_left = subL;
			}
			else
			{
				Pparent->_right = subL;
			}
			subL->_parent = Pparent;
		}

		//更新平衡因子
		subL->_bf = 0;
		parent->_bf = 0;
	}
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		Node* Pparent = parent->_parent;

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

		/*调整旋转后树的结构符合树的基本原则*/
		//1.整棵树的根
		if (parent==_root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (Pparent->_left == parent)
			{
				Pparent->_left = subR;
			}
			else
			{
				Pparent->_right = subR;
			}
			subR->_parent = Pparent;
		}

		//更新平衡因子
		subR->_bf = 0;
		parent->_bf = 0;
	}
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;
		
		RotateL(parent->_left);
		RotateR(parent);

		//更新平衡因子
		if (bf == -1)
		{
			subLR->_bf = 0;
			subL->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)
		{
			subLR->_bf = 0;
			subL->_bf = -1;
			parent->_bf = 0;
		}
		else if (bf == 0)
		{
			subLR->_bf = 0;
			subL->_bf = 0;
			parent->_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);

		//更新平衡因子
		if (bf == -1)
		{
			subRL->_bf = 0;
			subR->_bf = 1;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			subRL->_bf = 0;
			subR->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == 0)
		{
			subRL->_bf = 0;
			subR->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}

	}
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}
	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);
	}
	Node* _root = nullptr;
};

测试：test.cpp 

#include"AVL.h"

void test1()
{
	AVLTree<int, int> av;
	// 常规的测试⽤例
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	// 特殊的带有双旋场景的测试⽤例
	//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	for (auto e : a)
	{
		av.Insert({ e, e });
	}
	av.InOrder();
}
void test2()
{
	AVLTree<int, int> av;
	// 特殊的带有双旋场景的测试⽤例
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	for (auto e : a)
	{
		av.Insert({ e, e });
	}
	av.InOrder();
}

int main()
{
	cout << "单旋测试" << endl;
	test1();
	cout << "双旋测试" << endl;
	test2();
	return 0;
}

都市隸人
关注
专栏目录
『 C++ 』AVL树详解 ( 万字 )
小侯宝的博客
01-15 859
从上文可知,AVL树可以看作是一棵搜索二叉树,其为基于搜索二叉树在此基础上对树做了平衡的操作使其在结构上变得平衡不至于在极端情况下出现"歪脖子树"的情况;AVL树的定义与平衡搜索二叉树的结构上呈现类似;//将节点进行typedefpublic:protected:private://节点指针该篇文章中重点实现AVL树中的插入操作;
万字详解Nginx基础数据结构
H20555666的博客
05-25 477
适用于阅读Nginx源码及其原理以及巩固计算机编程知识的入门学习者的进阶学习
C++数据结构，三万字详解（强烈建议收藏）
Code Writers
09-17 922
C++常用数据结构 链表内存的申请与释放滑动窗口前缀和/积与后缀和/积差分数组线段树前缀树/字典树（Trie）单调栈单调队列并查集二叉树创建二叉树二叉树的遍历二叉树遍历的变体平衡二叉树（AVL）与二叉搜索树N叉树图拓扑排序链表链表（单链表）的基本操作及C语言实现链表中存放的不是基本数据类型，需要用结构体实现自定义：typedef struct Link{ char elem;//代表数据域 struct Link * next;//代表指针域，指向直接后继元素}link;12345next的值实际上就是下一
【数据结构复习之路】查找（严蔚敏版）万字详解
m0_74215326的博客
12-30 1793
int key;对二叉排序树进行中序遍历，可以得到一个递增的有序序列。以上讨论的表示查找表的各种结构的共同特点：记录在表中的位置和它的关键字之间不存在一个确定的关系，并且查找过程是：给定值依次和关键字集合中各关键字进行比较。散列表（Hash Table），又称为哈希表。是一种数据结构，特点：数据元素的关键字与其存储地址直接相关。记录的关键字与记录在表中的存储位置之间存在一种对应（函数）关系。若记录的关键字为 key，记录在表中的位置（称为哈希地址为f。
红黑树（万字图文详解）
originalHSL的博客
11-27 2222
本文讲解了红黑树的简单实现及其相关知识，希望对大家有所帮助！
【数据结构】什么是平衡二叉搜索树(AVL树)?
C/C++领域,数据结构,linux,MySQl学习者
09-29 579
数据结构之AVL树概念详解,内容包括:AVL树的概念,AVL树的操作(插入(左单旋,右单旋,左右双旋,右左双旋),删除)等操作的逻辑详解及图示。逻辑明了,图解丰富,适合入门学习.
『 C++ 』红黑树RBTree详解 ( 万字 )
小侯宝的博客
01-17 1438
AVL树AVL树采用的是利用平衡因子来控制;红黑树红黑树采用的是以颜色来判断树的结构;由上文概念中几个规则可能引出一个问题:红黑树中的新节点应该是什么颜色?黑色?红色?如果一个节点为红色,其两个孩子节点必定为黑色;对于每一个节点,从该节点到所有后代叶节点的简单路径上,都包含相同数目的黑色节点;根据这两个规则进行引入,权衡利弊可以发现新节点无论是黑色还是红色都有可能违反两条规则中的其中一条规则;但是对于两条规则的违反代价来说,新节点为黑色的代价要高于新节点为红色的代价;
模拟实现AVLTree超详解（C++）
m0_67430750的博客
05-09 908
模拟实现AVLTree万字详解，包括了KV模型和K模型。同时封装了正反迭代器（const和非const）。
万字长文详解数据结构：树 | 第6章 | Java版大话数据结构 | 二叉树 | 哈夫曼树 | 二叉树遍历 | 构造二叉树 | LeetCode练习 | Java
神马都会亿点点的毛毛张
06-29 826
线性结构是1️⃣对1️⃣的关系，如果处理1️⃣对多的情况，则需要使用树形结构🌲树形结构包括：二叉树、AVLAVLAVL树、B树、红黑树等，而二叉树是学其它树的基础，学好了二叉树才能在后续更难的树时得心应手🫱在介绍二叉树之前同时还需要整体的介绍一下树这个数据结构**定义：**🌳树是nn≥0n（n≥0）nn≥0个结点的有限集。当n0n = 0n0时，称为空树。在任意一棵非空树中应满足：有且仅有一个特定的称为根(Root)的结点；当n1n>1n1。
【专栏必读】王道考研408数据结构+计算机算法设计与分析万字笔记、题目题型总结、注意事项、目录导航和思维导图
热门推荐
快乐江湖的博客
11-23 4万+
各位老铁思维导图在我整理完笔记后会放上去的，我需要根据王道的思维导图重新再做一遍 文章目录一：有关注意事项二：关于专栏三：学习建议四：各专栏导航（各位老铁别催，质量优先）（1）第一章：绪论（2）第二章：线性表（3）第三章：栈和队列第四章：串第五章：二叉树第六章：图 首先感谢王道大大（手动比心），很用心在做了，大家可以看其中两节是否符合胃口 (王道408考研数据结构)第五章树-第三节1：二叉树遍历（先序、中序和后序） (王道408考研数据结构)第五章树-第四节2：平衡二叉树(AVL)及其旋转 一：有.
(王道408考研数据结构)第五章树-第四节4：红黑树基本概念及操作
快乐江湖的博客
11-21 2637
文章目录一：红黑树基本概念（1）什么是红黑树（2）红黑树的性质（3）为什么要给空结点（NIL）上色？（4）为什么最长路径一定不超过最短路径的2倍？（5）红黑树效率二：红黑树的实现（1）红黑树的结点（2）插入（3）判断是否为一棵红黑树 一：红黑树基本概念 （1）什么是红黑树 红黑树在二叉搜索树基础上，增加了一个域来标识结点的颜色，可以是红色和黑色。 通过对任何一条从根节点到叶子结点的简单路径上的各个结点的颜色的约束，红黑树可以确保没有一条路径能比其他路径长出2倍，也就是最长路径比最短路径的长度最长不超过2倍
Trie图——多模式串的字符串匹配（数据结构详解+模板题算法）
weixin_42420686的博客
07-17 1358
引入——多模式串的字符串匹配问题 对于字符串匹配问题，我们熟知的是KMP算法，它维护一个next数组，使模式串在失配的时候可以快速调整位置继续比较，而母串的指针不必回溯。（此处关于KMP不再介绍） 那么，对于有多个模式串的字符串匹配问题，如果想要做到在匹配的过程中母串指针不回溯，一个next数组显然是不够的。直观地，我们需要更复杂一些的数据结构来执行类似于next数组的功能。 这个数据结构就是Tr...
面试必问——万字详解Redis底层数据结构
wdj_yyds的博客
06-04 96
这是一种用于存储二进制数据的一种结构, 具有动态扩容的特点. 其实现位于src/sds.h与src/sds.c中。SDS的总体概览如下图:其中sdshdr是头部,buf是真实存储用户数据的地方. 另外注意, 从命名上能看出来, 这个数据结构除了能存储二进制数据, 显然是用于设计作为字符串使用的, 所以在buf中, 用户数据后总跟着一个\0. 即图中"数据" + "\0"是为所谓的buf。SDS有五种不同的头部. 其中sdshdr5实际并未使用到. 所以实际上有四种不同的头部, 分别如下:len。
数据结构_2.2、顺序表插入删除查找
cfy2401926342的博客
09-29 175
线性表：是具有相同数据类型的n （n≥0）个数据元素的有限序列顺序表：用顺序存储的方式实现线性表顺序存储：把逻辑上相邻的元素存储在物理 位置上也相邻的存储单元中，元素之间的关 系由存储单元的邻接关系来体现。ElemType ：就是你的顺序表中存放的数据元素类型。
【笔记】数据结构12
最新发布
m0_52024881的博客
09-29 357
看到的社区的一个知识总结，这里记录一下。
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 692
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
第五周做题总结_数据结构_队列与应用
2301_79837864的博客
09-29 497
银行营业大厅共服务3种客户，类型为A\B\C，大厅分别设置了3个窗口分别服务三种客户，即每个窗口只服务一种客户。现有一批客户来银行办理业务，每个客户都有类型和办理业务时间。每个窗口按照客户到来的顺序进行服务。编程实现它们的办理流程，请使用C++自带的queue必须使用队列实现，其他方法0分！队列queue的用法如下：包含头文件：#include定义一个整数队列对象：queue myQe;定义一个整数队列对象数组：queue myQA[10];入队操作：myQe.push(itemp);
数据结构升华部分：排序与字符串匹配算法应用
Rockivy的博客
09-26 911
这是哈希问题的逆问题题意理解已知H(x) = x%N，利用线性探测解决冲突问题。先给出散列映射的结果，反求输入顺序。当元素x被映射到H(x)位置，发现该位置已被y占用，则y一定在x之前被输入。限制：为确保解唯一，若几个元素可能同时被插入，则按从小到大顺序插入。因为12模11，余数为1，所以跟12冲突，放在12下面。后面都是类型的操作依次输入顺序为。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值