C++ AVL树手撕代码实现

已于 2022-07-10 18:59:36 修改
阅读量400 收藏 3
点赞数
分类专栏： C++秋招学习随笔 数据结构 文章标签： c++ 数据结构
于 2022-07-01 20:45:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zsiming/article/details/125564890
版权

文章目录

一、AVL树的旋转规则

1.AVL树概述(示意图)

AVL树是为了解决BST（二叉搜索树）树在一些情况下树的形状退化成线性链表而诞生的一种树。它有着BST树的特点（中序遍历是顺序的），但是有新的特点：对于每个节点来说，左右子树的高度差小于等于1.因此，AVL树是高度平衡的二叉搜索树。为了保持平衡，在四种情况下，树的结构要进行变形。这四种情况分别为：

  1. 左孩子的左子树太高
  2. 右孩子的右子树太高
  3. 左孩子的右子树太高
  4. 右孩子的左子树太高

在发生上面四种情况时，则需要变形操作。变形的操作分为左旋和右旋。

  1. 通过左旋，能让情况2变成平衡。
  2. 通过右旋，能让情况1变成平衡。
  3. 通过左平衡（左旋加右旋），能让情况3平衡。
  4. 通过右平衡（右旋加左旋），能让情况4平衡。

下面是四种情况的示意图：

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2. 四种操作的代码：

2.1 左旋

// 左旋
	Node* leftRotate(Node* node) {
		Node* child = node->right;
		node->right = child->left;
		child->left = node;
		
		// 更新高度
		node->_height = max(height(node->left), height(node->right)) + 1;
		child->_height = max(height(child->left), height(child->right)) + 1;

		return child;
	}

2.2 右旋

//右旋
	Node* rightRoate(Node* node) {
		Node* child = node->left;
		node->left = child->right;
		child->right = node;

		// 更新高度
		node->_height = max(height(node->left), height(node->right)) + 1;
		child->_height = max(height(child->left), height(child->right)) + 1;

		return child;
	}

2.3 左平衡（左旋+右旋）

//左平衡: 左孩子的右子树太高
	Node* leftBalance(Node* node) {
		node->left = leftRotate(node->left);
		return rightRoate(node);
	}

2.4 右平衡

//右平衡：右孩子的左子树太高
	Node* rightBalance(Node* node) {
		node->right = leftRotate(node->right);
		return rightRoate(node);
	}

二、AVL树的实现

AVL树的重点在于插入和删除操作。

1.插入操作

  1. AVL树的插入和BST树的插入一样，都是通过深度遍历来实现的。不同的地方是AVL树在每层递归结束之后，都会检查当前的节点是否满足高度平衡这个条件。如果不满足，就使用左右旋转或左右平衡来让当前节点平衡。

2.插入操作代码

// 内部的插入操作
	Node* insert(Node* node, const int& val) {
		if (node == nullptr) {
			return new Node(val);
		}

		if (node->_val > val) {
			node->left = insert(node->left, val);
			// 调整高度
			if (height(node->left) - height(node->right) > 1) {
				if (height(node->left->left) >= height(node->left->right)) {
					node = rightRoate(node);
				} else {
					node = leftBalance(node);
				}
			}
		} else if (node->_val < val) {
			node->right = insert(node->right, val);
			// 调整高度
			if (height(node->right) - height(node->left) > 1) {
				if (height(node->right->right) >= height(node->right->left)) {
					node = leftRotate(node);
				} else {
					node = rightBalance(node);
				}
			}
		} else {
			; //已经有该节点了，不做任何操作
		}

		node->_height = max(height(node->left), height(node->right)) + 1;

		return node;	
	}

3.删除操作

AVL树的删除是通过二分搜索实现的。在找到需要删除的节点后，可以分为三种情况：

  1. 待删除的节点有左右孩子
  2. 待删除的节点只有左孩子
  3. 待删除的节点只有右孩子

如果删除的节点同时有左右孩子，那么为了减少旋转操作：我们可以找出待删除节点究竟是左子树比较高还是右子树比较高。如果是左子树比较高，我们就把待删除节点的前驱节点（最后一个大于待删除节点的节点）数据覆盖到待删除节点上，再删除前驱节点。反之，我们就把待删除节点的后继节点（第一个大于待删除节点的节点）覆盖到待删除节点上，再删除后继节点。

而如果只有左孩子或者右孩子的话，就比较简单：待删除节点释放后，把左（右）孩子返回即可。

完成了删除操作之后，我们在每层回溯时来检查每个节点的左右子树高度是否平衡。如果不平衡，就使用左右旋转或左右平衡来让当前节点平衡。

4.删除操作代码

// 内部的删除操作
	Node* remove(Node* node, const int& val) {
		if (node == nullptr) return nullptr;

		if (node->_val > val) {
			node->left = remove(node->left, val); 
			// 已经删除完毕，在回溯中检查左子树有没有因为删除而失衡
			if (height(node->right) - height(node->left) > 1) {
				if (height(node->right->right) >= height(node->right->left)) {
					node = leftRotate(node);
				} else {
					node = rightBalance(node);
				}
			}
		} else if (node->_val < val) {
			node->right = remove(node->right, val);
			// 已经删除完毕，在回溯中检查右子树有没有因为删除而失衡
			if (height(node->left) - height(node->right) > 1) {
				if (height(node->left->left) >= height(node->left->right)) {
					node = rightRoate(node);
				} else {
					node = leftBalance(node);
				}
			}
		} else {
			// 1.存在左右孩子
			if (node->left && node->right) {
				// 如果左子树比右子树高就用前驱补到node的位置
				if (height(node->left) >= height(node->right)) {
					Node* pre = node->left;
					while (pre->right != nullptr) {
						pre = pre->right;
					}
					// 将前驱的数据覆盖到当前节点中
					node->_val = pre->_val;
					// 删除前驱
					node->left = remove(node->left, pre->_val);
				} else {
					// 如果左子树比右子树矮就用后继补到node的位置
					Node* post = node->right;
					while (post->left != nullptr) {
						post = post->left;
					}
					// 将后继的数据覆盖到node的位置
					node->_val = post->_val;
					// 删除后继
					node->right = remove(node->right, post->_val);
				}
			} else {
				// 2.只存在左孩子
				if (node->left != nullptr) {
					Node* tmp = node->left;
					delete node;
					return tmp;
				}
				// 3.只存在右孩子
				if (node->right != nullptr) {
					Node* tmp = node->right;
					delete node;
					return tmp;
				}
				// 4.没有左孩子和没有右孩子
				if (node->left == nullptr && node->right == nullptr) {
					delete node;
					return nullptr;
				}
			}
		}

		node->_height = max(height(node->left), height(node->right)) + 1;
		
		return node;
	}

3、完整实现

#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;

struct Node {
	Node* left;
	Node* right;
	int _val;
	int _height;
	Node(int val) : _val(val), _height(1), left(nullptr), right(nullptr) {}
};

class AVLTree {
private:
	
	Node* _root;

	// 得到树的高度
	int height(Node* node) {
		return node ? node->_height : 0;
	}

	// 左旋
	Node* leftRotate(Node* node) {
		Node* child = node->right;
		node->right = child->left;
		child->left = node;
		
		// 更新高度
		node->_height = max(height(node->left), height(node->right)) + 1;
		child->_height = max(height(child->left), height(child->right)) + 1;

		return child;
	}

	//右旋
	Node* rightRoate(Node* node) {
		Node* child = node->left;
		node->left = child->right;
		child->right = node;

		// 更新高度
		node->_height = max(height(node->left), height(node->right)) + 1;
		child->_height = max(height(child->left), height(child->right)) + 1;

		return child;
	}

	//左平衡: 左孩子的右子树太高
	Node* leftBalance(Node* node) {
		node->left = leftRotate(node->left);
		return rightRoate(node);
	}

	//右平衡：右孩子的左子树太高
	Node* rightBalance(Node* node) {
		node->right = leftRotate(node->right);
		return rightRoate(node);
	}

	// 内部的插入操作
	Node* insert(Node* node, const int& val) {
		if (node == nullptr) {
			return new Node(val);
		}

		if (node->_val > val) {
			node->left = insert(node->left, val);
			// 调整高度
			if (height(node->left) - height(node->right) > 1) {
				if (height(node->left->left) >= height(node->left->right)) {
					node = rightRoate(node);
				} else {
					node = leftBalance(node);
				}
			}
		} else if (node->_val < val) {
			node->right = insert(node->right, val);
			// 调整高度
			if (height(node->right) - height(node->left) > 1) {
				if (height(node->right->right) >= height(node->right->left)) {
					node = leftRotate(node);
				} else {
					node = rightBalance(node);
				}
			}
		} else {
			; //已经有该节点了，不做任何操作
		}

		node->_height = max(height(node->left), height(node->right)) + 1;

		return node;	
	}

	// 内部的删除操作
	Node* remove(Node* node, const int& val) {
		if (node == nullptr) return nullptr;

		if (node->_val > val) {
			node->left = remove(node->left, val); 
			// 已经删除完毕，在回溯中检查左子树有没有因为删除而失衡
			if (height(node->right) - height(node->left) > 1) {
				if (height(node->right->right) >= height(node->right->left)) {
					node = leftRotate(node);
				} else {
					node = rightBalance(node);
				}
			}
		} else if (node->_val < val) {
			node->right = remove(node->right, val);
			// 已经删除完毕，在回溯中检查右子树有没有因为删除而失衡
			if (height(node->left) - height(node->right) > 1) {
				if (height(node->left->left) >= height(node->left->right)) {
					node = rightRoate(node);
				} else {
					node = leftBalance(node);
				}
			}
		} else {
			// 1.存在左右孩子
			if (node->left && node->right) {
				// 如果左子树比右子树高就用前驱补到node的位置
				if (height(node->left) >= height(node->right)) {
					Node* pre = node->left;
					while (pre->right != nullptr) {
						pre = pre->right;
					}
					// 将前驱的数据覆盖到当前节点中
					node->_val = pre->_val;
					// 删除前驱
					node->left = remove(node->left, pre->_val);
				} else {
					// 如果左子树比右子树矮就用后继补到node的位置
					Node* post = node->right;
					while (post->left != nullptr) {
						post = post->left;
					}
					// 将后继的数据覆盖到node的位置
					node->_val = post->_val;
					// 删除后继
					node->right = remove(node->right, post->_val);
				}
			} else {
				// 2.只存在左孩子
				if (node->left != nullptr) {
					Node* tmp = node->left;
					delete node;
					return tmp;
				}
				// 3.只存在右孩子
				if (node->right != nullptr) {
					Node* tmp = node->right;
					delete node;
					return tmp;
				}
				// 4.没有左孩子和没有右孩子
				if (node->left == nullptr && node->right == nullptr) {
					delete node;
					return nullptr;
				}
			}
		}

		node->_height = max(height(node->left), height(node->right)) + 1;
		
		return node;
	}

public:
	AVLTree() : _root(nullptr) {}
	
	// 得到头部节点
	Node* getHead() {
		return _root;
	}

	// 用户调用的插入操作
	void insert(const int& val) {
		_root = insert(_root, val);
	}

	// 用户调用的删除操作
	void remove(const int& val) {
		_root = remove(_root, val);
	}

	

};


void printTree(Node* root) {
	queue<Node*> que;
	if (root) que.push(root);

	while (!que.empty()) {
		int size = que.size();

		for (int i = 0; i < size; ++i) {
			Node* cur = que.front(); que.pop();
			cout << cur->_val << " ";

			if (cur->left) que.push(cur->left);
			if (cur->right) que.push(cur->right);
		}
		cout << endl;
	}
}


int main() {
	
	{	
		// 测试左旋
		AVLTree tree;
		for (int i = 0; i < 10; ++i) {
			tree.insert(i);
		}
		
		// 打印二叉树
		Node* head = tree.getHead();
		printTree(head);
		
		// 测试删除操作
		tree.remove(7);
		tree.remove(4);
		tree.remove(5);
		tree.remove(6);
		head = tree.getHead();
		printTree(head);

	}
	// 测试右旋
	/*{
		AVLTree tree;
		for (int i = 10; i >= 0; --i) {
			tree.insert(i);
		}

		Node* head = tree.getHead();
		printTree(head);
	}*/

	return 0;
}
zsiming
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVL树的c++实现
08-03
在C++中实现AVL树，我们可以利用模板类来增强代码的通用性，并通过智能指针如`shared_ptr`来管理内存，避免内存泄漏。 首先，我们需要定义一个AVL树节点结构体，包括节点值、高度、左子树和右子树的指针。由于我们...
AVL树 C++ 实现
03-05
在C++中实现AVL树，我们可以利用模板类来创建一个泛型的数据结构，这样就可以处理不同类型的元素。 首先，我们需要定义AVL树的节点结构。每个节点包含三个部分：键（key）存储元素值，高度（height）用于计算树的...
C++之 AVL树，手撕代码！
flyingcloud6的博客
11-30 479
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树。在先左后右调节平衡因子的时候比较复杂，因为subL，subR,ptr的平衡因子情况是都要进行改变的。因为插入了节点那么自插入节点之上的节点的平衡因子是一定要改变的那么我们就可以分为多种情况。
手撕AVL树 (C++ 实现）
林慢慢的博客
06-29 971
AVL 树的定义、代码实现、性能分析
C++手撕AVL树
分享学习的知识，记录我的技术成长道路
06-09 517
要手撕AVL树，我们首先要知道什么是AVL树。AVL树是在二叉搜索树的基础之上改造的。当我们插入的是一个有序的序列的时候，二叉搜素树会使用一条直线来进行存储，这样并不利于查找。 当遇到这种情况的时候我们就需要对这棵树来进行调整。AVL树会通过旋转等操作，来规避这种情况。最终满足每一个节点的平衡因子的绝对值......
C++ AVL树底层实现原理
努力学习C/C++
04-09 846
这篇从了解到使用map，map也是搜索二叉树，因为搜索二叉树会出现歪脖子树的情况，本篇就讲如何解决歪脖子树。记住口令 旋转 旋转 旋转！！！重要的事说三边。搜索二叉树加入平衡因子 旋转 就成了传说之中的AVL树AVL树1.1 AVL树的概念二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数G.M.Adelson-Velskii和E.M.Landis在1962。
【C++】手撕AVL树
AAlykk的博客
03-15 1730
相信大家肯定听过在C++大名鼎鼎的两颗树，这两颗树分别是AVL树和红黑树，学过的小伙伴听到都是瑟瑟发抖，像一些大厂中可能会考手撕AVL树或红黑树。学习这两棵树确实难度很大，正所谓难度越大动力就越大，那本篇我们学习这两棵树的一颗树--AVL树。⭐主体。
C++手撕红黑树
分享学习的知识，记录我的技术成长道路
08-07 642
红黑树在表意上就是一棵每个节点带有颜色的二叉搜索树，并通过对节点颜色的控制，使该二叉搜索树达到尽量平衡的状态。红黑树确保没有一条路径比其他路径长两倍。和AVL树不同的是，AVL树是一棵平衡树，而红黑树可能平衡也可能不平衡(因为是尽量平衡的状态)每一次插入都对根节点置为黑操作，因为第一种情况可能导致根节点不是黑。同时对根节点置黑也并不违反三条规定。...
【高阶数据结构（壹）】——一步一步教你手撕AVL树（增删查改）画图详解，内含代码实现包含注释）
sjp11的博客
01-17 923
???? 1.AVL树的概念 AVL树一颗二叉搜索树 左右子树高度之差(简称平衡因子)的绝对值不超过1。 如果一颗AVL树有n个节点，其高度可以保持在O(logn),搜索的时间复杂度是O(logn). ???? 2.AVL树节点的定义 template<class K,class V> struct AVLTreeNode { AVLTreeNode* _left;//左孩子节点 AVLTreeNode* _right;//右孩子节点 AVLTreeNode* parent;//
【C++模拟实现】手撕AVL树
m0_74215144的博客
09-10 450
本篇博客将会介绍AVL树的模拟实现(模拟AVL树的插入)，以及如何去验证是否为AVL树，AVL树的实现可以锻炼自己的调试能力。
【C++技能树】手撕AVL树 --插入与旋转详解
qq_62839589的博客
09-13 295
手撕AVL树 --插入与旋转详解
C++平衡Avl树实现.zip
08-20
总的来说，C++实现AVL树涉及到理解二叉搜索树、平衡树的概念，熟悉递归算法，掌握旋转操作的逻辑，以及编写相应的测试用例。通过这样的实现，我们可以创建一个高效的数据结构，用于处理大量数据的快速查找、插入和...
AVL树的模拟实现代码
06-19
AVL树代码
C++版AVL树课程设计源代码
11-04
该程序通过C++实现了AVL树的一些基础操作：1.编写AVL树判别程序，并判别一个二叉搜索树是否为AVL树；2.实现AVL树的ADT，包括其上的基本操作：结点的加入和删除；3.实现基本操作的动态演示(图形演示)；最重要的是，该...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1244
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
最新发布
zhyjhacker的博客
07-25 705
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 293
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1154
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
非递归实现AVL树与线性表操作
"该资源是针对非线性数据结构，特别是AVL树的非递归实现的实验指导，包括线性表的双链表实现、树排序和银行账户管理系统的应用。实验旨在帮助在校大学生掌握数据结构的核心概念，并通过C++编程实践来提升技能。实验...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值