数据结构——4自平衡二叉搜索树(AVL)

最新推荐文章于 2020-08-16 00:31:49 发布
最新推荐文章于 2020-08-16 00:31:49 发布
阅读量289 收藏
点赞数 1
文章标签： 二叉树 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zero_Muzi/article/details/104657058
版权

实现简单的自平衡二叉搜索树(AVL)

在实现二叉搜索树(BST)的基础上增加高度平衡旋转

结构体Node：左结点left、右结点right、数据data、高度height
类BST：根结点root

主要功能有：自平衡旋转、添加、删除、查询、遍历(前序遍历、中序遍历、后序遍历、层序遍历、深度优先搜索、广度优先搜索)、高度计算

时间复杂度：
1、自平衡旋转
比较左右子树根结点高度，时间复杂度为O(1)
2、添加
时间复杂度为O(logn)，最多两次单旋转（同一个地方）
3、删除
时间复杂度为O(logn)，多次旋转，一直到根都有可能

简单描述一下二叉搜索树的删除过程，可以分为以下四种情况
a) 要删除的节点没有左右孩子
b) 要删除的节点只有左孩子（用左子结点代替）
c) 要删除的节点只有右孩子（用右子结点代替）
d) 要删除的节点有左右孩子（用后继结点代替）

我这里不直接用后继结点替代被删除结点，而是根据左右两颗子树高度，选择前继结点或者后继结点，可无需被删除结点以上的旋转操作
因此只有两种情况：
a) 要删除的节点没有左右孩子
b) 要删除的节点有孩子(根据左右两颗子树高度，选择前继结点或者后继结点)

4、查询
时间复杂度为O(logn)
5、遍历
遍历全结点，时间复杂度为O(n)
6、高度计算
因为AVL树维护了结点高度，只需返回根结点高度，时间复杂度为O(1)

总结：
1、二叉树算法的核心是递归，实现二叉树的任何功能都可通过递归实现
2、前序遍历是dfs的一种
3、BFS就是层序遍历，可以用队列的特点来实现
4、中序遍历是二叉搜索树结点从小到大排序
5、高度计算可以用前序遍历来实现
6、递归处理每个分支的一半，跟二分法类似，属于减治法或者分治法，用分治法的主定理来算T(n)=aT(n/b)+f(n)，f(n)∈O(nd)，这里a=1，b=2，d=0，a=bd，因此T(n)∈O(ndlogn)=O(logn)
7、AVL树通过维护结点高度来计算平衡因子，不需要每层递归都计算左右子树高度(O(n))，不然会导致添加和删除结点的时间复杂度都为O(nlogn)

#include<iostream>
#include<algorithm>//借用max函数
#include<vector>
using namespace std;

template<typename T>
struct Node {
	Node<T>* left;
	Node<T>* right;
	T data;
	int height;
	Node(T val) :data(val), height(1),left(nullptr), right(nullptr) {}
};

template<typename T>
class AVL {
private:
	Node<T>* root;

	//自平衡旋转：右单转、左单转、左右双转、右左双转
	Node<T>* insert_rotate(Node<T>* root, T val, int lr) {
		if (lr == 0) {
			if (rheight(root->left) - rheight(root->right) == 2) {
				if (root->left->data >val)
					root = rightRotate(root);
				else root = lrRotate(root);
			}
		}
		else {
			if (rheight(root->right) - rheight(root->left) == 2) {
				if (root->right->data < val)
					root = leftRotate(root);
				else root = rlRotate(root);
			}
		}
		return root;
	}

	Node<T>* delete_rotate(Node<T>* root, T val, int lr) {
		if (lr == 1) {
			if (rheight(root->left) - rheight(root->right) == 2) {
				if (root->left->data > val)
					root = rightRotate(root);
				else root = lrRotate(root);
			}
		}
		else {
			if (rheight(root->right) - rheight(root->left) == 2) {
				if (root->right->data < val)
					root = leftRotate(root);
				else root = rlRotate(root);
			}
		}
		return root;
	}

	Node<T>* rightRotate(Node<T>* root) {
		Node<T>* rleft = root->left;
		root->left = rleft->right;
		rleft->right = root;
		root->height = max(rheight(root->left), rheight(root->right)) + 1;
		rleft->height = max(rheight(rleft->left), rheight(rleft->right)) + 1;
		return rleft;
	}
	Node<T>* leftRotate(Node<T>* root) {
		Node<T>* rright = root->right;
		root->right = rright->left;
		rright->left = root;
		root->height = max(rheight(root->left), rheight(root->right)) + 1;
		rright->height = max(rheight(rright->left), rheight(rright->right)) + 1;
		return rright;
	}
	Node<T>* lrRotate(Node<T>* root) {
		root->left = leftRotate(root->left);
		return rightRotate(root);
	}
	Node<T>* rlRotate(Node<T>* root) {
		root->right = rightRotate(root->right);
		return leftRotate(root);
	}

	//插入辅助函数
	Node<T>* insert(Node<T>* root, T val) {
		if (root) {
			if (root->data > val) {
				root->left = insert(root->left, val);
				root->height = max(rheight(root->left), rheight(root->right)) + 1;
				root = insert_rotate(root, val, 0);
				return root;
			}
			if (root->data < val) {
				root->right = insert(root->right, val);
				root->height = max(rheight(root->left), rheight(root->right)) + 1;
				root = insert_rotate(root, val, 1);
				return root;
			}
			return nullptr;
		}
		return new Node<T>(val);
	}

	//删除辅助函数
	Node<T>* del(Node<T>* root, T val) {
		if (root) {
			if (root->data > val) {
				root->left = del(root->left, val);
				if(root->left)
				root->left->height= max(rheight(root->left->left), rheight(root->left->right)) + 1;
				root->height = max(rheight(root->left), rheight(root->right)) + 1;
				if (root->right) {
					if (root->right->right)
						root = delete_rotate(root, root->right->right->data, 0);
				}
			}
			else if (root->data < val) {
				root->right = del(root->right, val);
				if (root->right)
				root->right->height = max(rheight(root->right->left), rheight(root->right->right)) + 1;
				root->height = max(rheight(root->left), rheight(root->right)) + 1;
				if (root->left) {
					if (root->left->left)
						root = delete_rotate(root, root->left->left->data, 1);
				}
			}
			else {
				Node<T>* r = nullptr;
				if (root->left || root->right) {
					r = root;
					if (rheight(root->left) > rheight(root->right)) {
						Node<T>* left = r->left;
						int i;
						for (i = 0; left->right != nullptr; i++) {
							left = left->right;
							if (i)
								r = r->right;
							else r = r->left;
						}
						if (i) {
							r->right = left->left;
							if (root)
								del(root, left->data);
							left->right = root->right;
							left->left = root->left;
						}
						else left->right = root->right;
						r = left;

					}
					else {
						Node<T>* right = r->right;
						int i;
						for (i = 0; right->left != nullptr;i++) {
							right = right->left;
							if (i)
								r = r->left;
							else r = r->right;
						}

						if (i) {
							r->left = right->right;
							if (root)
								del(root, right->data);
							right->right = root->right;
							right->left = root->left;
						}
						else right->left = root->left;
						r = right;
					}
				}
				root->left = nullptr;
				root->right = nullptr;
				root = r;

			}
			return root;
		}
		return nullptr;
	}

	//查找辅助函数
	bool find(Node<T>* root, T val) {
		if (root) {
			if (root->data == val)
				return true;
			if (root->data > val)
				return find(root->left, val);
			else return find(root->right, val);
		}
		return false;
	}

	//遍历辅助函数：前序遍历、中序遍历、后序遍历
	void preOrder(Node<T>* root) {
		if (root) {
			cout << root->data;
			preOrder(root->left);
			preOrder(root->right);
		}
	}
	void inOrder(Node<T>* root) {
		if (root) {
			inOrder(root->left);
			cout << root->data;
			inOrder(root->right);
		}
	}
	void postOrder(Node<T>* root) {
		if (root) {
			postOrder(root->left);
			postOrder(root->right);
			cout << root->data;
		}
	}

	int rheight(Node<T>* node) {
		if (node)
			return node->height;
		return 0;
	}

public:
	AVL(T val) { root = new Node<T>(val); }
	~AVL() {}

	//添加
	bool insert(T val) {
		Node<T>* p = insert(root, val);
		if (p) {
			root = p;
			return true;
		}
		return false;
	}

	//删除
	bool del(T val) {
		Node<T>* p = del(root, val);
		root->height = max(rheight(root->left), rheight(root->right)) + 1;
		if (p) {
			root = p;
			return true;
		}
		return false;
	}

	//查询
	bool find(T val) {
		return find(root, val);
	}

	//遍历：前序遍历（dfs）、中序遍历、后序遍历、层序遍历（bfs）
	//前序遍历
	void preOrder() {
		preOrder(root);
		cout << endl;
	}
	//中序遍历
	void inOrder() {
		inOrder(root);
		cout << endl;
	}
	//后序遍历
	void postOrder() {
		postOrder(root);
		cout << endl;
	}
	//层序遍历
	void levelOrder() {
		if (root) {
			vector<Node<T>*> nodes;
			nodes.push_back(root);
			int n = 1;
			for (int i = 0; i < n; i++) {
				cout << nodes[i]->data;
				if (nodes[i]->left) {
					nodes.push_back(nodes[i]->left);
					n++;
				}
				if (nodes[i]->right) {
					nodes.push_back(nodes[i]->right);
					n++;
				}
			}
		}
		cout << endl;
	}
	//深度优先搜索
	void dfs() { preOrder(); }
	//广度优先搜索
	void bfs() { levelOrder(); }

	int height() { return root->height; }
};


int main() {
	AVL<int> avl(4);
	//添加测试
	cout << "----------添加测试----------" << endl;
	cout << "前序遍历：";
	avl.preOrder();
	avl.insert(2);
	cout << "前序遍历：";
	avl.preOrder();
	avl.insert(6);
	cout << "前序遍历：";
	avl.preOrder();
	avl.insert(1);
	cout << "前序遍历：";
	avl.preOrder();
	avl.insert(3);
	cout << "前序遍历：";
	avl.preOrder();
	avl.insert(7);
	cout << "前序遍历：";
	avl.preOrder();
	avl.insert(5);
	cout << "前序遍历：";
	avl.preOrder();
	avl.insert(8);
	cout << "前序遍历：";
	avl.preOrder();

	/*
		   4
		 ↙	↘
		2     6
	  ↙ ↘ ↙ ↘
	  1   3 5   7
			     ↘
			      8
	*/

	//高度平衡测试
	cout << "----------高度平衡测试----------" << endl;
	avl.insert(9);
	cout << "前序遍历：";
	avl.preOrder();
	/*
		   4
		 ↙	↘
		2     6
	  ↙ ↘ ↙ ↘
	  1   3 5   8
			  ↙ ↘
			  7   9
	*/

	//遍历测试
	cout << "----------遍历测试----------" << endl;
	cout << "前序遍历：";
	avl.preOrder();
	cout << "中序遍历：";
	avl.inOrder();
	cout << "后序遍历：";
	avl.postOrder();
	cout << "层序遍历：";
	avl.levelOrder();
	cout << "深度优先搜索：";
	avl.dfs();
	cout << "广度优先搜索：";
	avl.bfs();

	//高度计算测试
	cout << "----------高度计算测试----------" << endl;
	cout << "height:" << avl.height() << endl;

	//删除测试
	cout << "----------删除测试----------" << endl;
	cout << "删除4：" << avl.del(4) << endl;
	cout << "前序遍历：";
	avl.preOrder();

	//查询测试
	cout << "----------查询测试----------" << endl;
	cout << "查找7：" << avl.find(7) << endl;
}

附上测试用例
如有不对，请大佬指出orz

小小魔姬
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
自平衡二叉搜索树
aitie1479的博客
01-08 97
2018-01-05 23:54:29 二叉搜索树的查找时间是和树高成正比的，在最坏条件下，查找的时间复杂度为O（n），因此要尽可能的使树的两边保持平衡，由此出现了自平衡的二叉树。 一、AVL树 在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下的时间复杂度都是O（lo...
自平衡二叉查找树总结
qq_28400747的博客
07-02 185
1.概念 在介绍自平衡二叉查找树之前，先说一下二叉树，这里就简单列一下概念来自《数据结构和算法分析》 二叉树：是一棵树，每个节点不能多于两个儿子 二叉查找树：树中所有项都可以被排序，即树中每个节点x，它的左子树所有项都小于x，它的右子树所有项都大于x。 自平衡的二叉查找树：根据某些平衡条件保证树的深度（avl和红黑树） 2AVL树 AVL树严格保障树的高度达到某种条件：左子树和右子树高度相差不能大于1。但是每次插入或者删除的时候都有可能破坏平衡条件，解决的方法是树的旋转。 树的旋转 1.左旋
【二叉搜索树】(四) 高度平衡的二叉搜索树
闻韶
08-16 709
LeetCode - 探索卡片 - 二叉搜索树 - 附录 - 高度平衡的二叉搜索树
自平衡二叉搜索树（AVL Trees)
Sun.ME的博客
02-23 799
自平衡二叉树、平衡二叉树、二叉树、AVL树
AVL树——自平衡二叉搜索树
JoJo's blog
11-24 406
概念 AVL（Adelson-Velskii and Landis）树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis，他们在 1962 年的论文《An algorithm for the organization of information》中发表了它。 AVL树是一种自平衡二叉搜索树。 特征 满足二叉搜索树的特征，即任何一个节点的值比左孩子的值大，比右...
数据结构实验——树和二叉树子系统
07-31
在本实验“数据结构实验——树和二叉树子系统”中，我们将深入理解二叉树的特性和操作。 首先，实验目的主要涵盖以下几个方面： 1. **理解二叉树特点**：二叉树的每个节点至多有两个子节点，它允许快速查找、插入...
数据结构平衡二叉排序树
02-13
AVL树是一种自平衡的二叉搜索树，它的每个节点都包含一个平衡因子，这个因子是该节点的左子树高度与右子树高度的差值。平衡因子的取值范围是-1、0或1，这确保了树的高度始终保持在一个相对较小的范围内，从而保证了...
VC++2012编程演练数据结构《9》平衡二叉搜索树
11-19
AVL树是最早被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名AVL。AVL树的关键特点是任意节点的两个子树高度差不超过1，这使得其查找效率为O(log n)。为了实现这一平衡，AVL...
数据结构-用户登录实验-二叉查找树AVL树实现
05-23
接下来，AVL树（Adelson-Velsky and Landis tree）是最早被提出的自平衡二叉查找树。在AVL树中，任何节点的两个子树的高度差不超过1，因此它保持了较好的平衡性。这种平衡特性确保了AVL树在最坏情况下的操作时间...
广工数据结构实验——平衡二叉树
07-06
**AVL树**（Adelson-Velsky and Landis tree）是最早被提出的自平衡二叉搜索树，由Georgy Adelson-Velsky和Eugene Landis于1962年提出。AVL树的特点是任何节点的两个子树的高度差不超过1，因此其具有良好的查询性能...
数据结构-自平衡二叉排序树AVL Tree（基础知识）
abcnull 的博客
02-29 853
文章目录平衡二叉树简介自平衡二叉排序树的旋转自平衡二叉排序树的优势自平衡二叉排序树的缺陷自平衡二叉排序树的缺陷补漏 平衡二叉树简介 平衡二叉树 AVL Tree 二叉树有一个最大的缺陷就是在最糟糕情况下，二叉树呈现单链表的数据结构。为了杜绝这个问题产生了中特定规则的树，其中一个非常著名的是平衡二叉树。 平衡二叉树每个结点，其左右子树的深度之差的绝对值小于等于 1 快在查找，删除和插入影响性能 自平...
数据结构---自平衡二叉树AVL
inferno_devil的博客
05-23 288
1.01 AVL树 名字缘由：G.M.Adelson-Velsky和E.M.Landis 。是一种最早的自平衡二分搜索树结构 。 AVL树既是平衡二叉树。AVL树的定义首先要求该树是二叉查找树（满足排序规则），并在此基础上增加了每个节点的平衡因子的定义，一个节点的平衡因子是该节点的左子树树高减去右子树树高的值。 平衡因子BF：该节点的左子树的深度减去它的右子树深度。（平衡二叉树上的所有节...
c++写AVL二叉平衡搜索树算法
BlackCarDriver的博客
03-20 313
下面是我写的avl数算法模板，虽然已过三个月，现在再次想重写，仍然难以找到可以在优化的地方。 这个算法里面用到的递归操作和其他细节都很多，一旦某处写错，可能造成难以发现的bug。。。 下面是代码，注释照旧，发现不足之处或有所疑问欢迎留言。 #include<iostream> #include<stdio.h> #include<vector> #include...
自已作图搞清楚自平衡的二分搜索树（一）---AVL树的定义及原理
我的博客
07-21 483
文章目录一、背景二、平衡二分搜索树（AVL树）2.1 AVL树的基本概念结点高度平衡因子 一、背景 二叉树是一种常用的数据结构，更是实现众多算法的一把利器。（基本定义可参考《自己动手作图深入理解二叉树、满二叉树及完全二叉树》） 二分搜索树（Binary Search Tree）做为一种能实现快速定位查找的二叉树也得到了广泛应用（算法可参考《用一个图书库实例搞懂二分搜索树的底层原理》）。 1 二分搜索树是一颗二叉树 2 二分搜索树每个节点的左子树的值都小于该节点的值，每个节点右子树的值都大于该节点的值 3
邓俊辉版数据结构整理(4)：平衡二叉搜索树（AVL树）
huofire001的博客
01-05 740
节点数目固定时，兄弟子树高度越接近，全树也将倾向于更低。 由n个节点组成的二叉树，高度不低于，恰好为时，称为理想平衡。 高度渐进地不超过O()，即可称作适度平衡 zig旋转 zag旋转 平衡因子： balFac(v) = height(lc(v)) - height(rc(v));左子树高度减右子树高度。 若树平衡，则   -1 =&lt; balFac(v) =&lt; 1...
平衡二叉树（c++）实现
知其所以然
03-21 1517
平衡二叉树（c++）实现 ------ 欢迎指正------- 1、参考资料： 　　书籍：《算法导论》 　　博文：http://www.cnblogs.com/fivestudy/fivestudy/p/10340647.html 原理讲的很棒。有动画，方便理解。 　　这个网站可以清晰看清楚平衡二叉树的插入删除等详细过程：https:...
AVL树的插入与删除
热门推荐
朱广健的博客
05-25 1万+
AVL树是一种高度平衡的二叉搜索树，其每一个结点的左树高和右树高相差不大于1。这个性质使得AVL树的搜索效率要比普通的二叉搜索树要高，因为对于一组递增的数组，其构成的二叉搜索树会是一个链表，搜索时间复杂度自然就是O(n)，而其构成的AVL树则肯定是一个搜索效率为O(lg(n))的二叉树。也正因为此，为了保持其平衡的性质，AVL树的插入和删除要比普通二叉搜索树要复杂。 1. 通过旋转保持AVL树的
Python 数据结构 用Python实现AVL树 不同操作的时间复杂度详解
KadeWu的博客
06-15 951
AVL树的Python实现AVL树介绍Python实现NodeaddremovegetHeightrebalance完整代码测试总结1.AVL树2.操作复杂度 AVL树介绍 普通的 二叉搜索树介绍： https://blog.csdn.net/qq_40831558/article/details/106664884 AVL 树是一种平衡二叉树，得名于其发明者的名字（ Adelson-Velskii 以及 Landis）。（可见名字长的好处，命名都能多占一个字母出来）。平衡二叉树递归定义如下： 左右子树的
数据结构_平衡二叉搜索树(AVL树)
xc13212777631的博客
06-21 8652
平衡二叉搜索树 在二叉搜索树中，已经知道search、insert和remove等主要接口的运行时间均正比于树的高度。但是在最坏的情况下，二叉搜索树可能退化成列表，此时查找的效率会降至O(n)。因此，通常通过控制树高，来控制最坏情况下的时间复杂度。 对于节点数目固定的BST，越是平衡，最坏情况下的查找速度越快，如下图所示： 为了理解平衡二叉树，我们首先要理解几个主要概念，理想平衡与适度平...
高级数据结构：AVL树与平衡二叉搜索树解析
2. AVL树：AVL树是一种自平衡的二叉搜索树，通过限制任何节点的左右子树高度差不超过1来确保平衡。AVL树的平衡性质保证了查找、插入和删除操作的最坏时间复杂度为O(log n)。当插入或删除导致树不平衡时，通过旋转...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小小魔姬

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

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

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

打赏作者

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

抵扣说明：

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

余额充值