平衡二叉树AVLTree

最新推荐文章于 2021-06-09 11:14:12 发布
最新推荐文章于 2021-06-09 11:14:12 发布
阅读量110 收藏
点赞数
分类专栏： C/C++ 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yqq1997/article/details/116783493
版权

AVLTree

#pragma once

/**
*@time: 2019-10-28 18:43:40
*@author: yqq
*@descriptions: 平衡二叉树
*/

//参考 : https://www.tutorialspoint.com/cplusplus-program-to-implement-avl-tree


#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string>
#include <algorithm>
#include <vector>
#include <list>
#include <sstream>
#include <map>
#include <boost/algorithm/string.hpp>

using namespace std;



template <typename T> 
struct AVLTree
{
public:

	AVLTree() 
	{
		_m_pRoot = nullptr;
	}

	virtual ~AVLTree() 
	{
		Destroy();
	}

	template <typename CompareableType>
	struct AVLTreeNode
	{
		CompareableType						data;
		AVLTreeNode<CompareableType>		*pLeft;
		AVLTreeNode<CompareableType>		*pRight;
	};


protected:
	AVLTreeNode<T>  *_m_pRoot;


public:
	void Insert(const T &value)
	{
		 _Insert(_m_pRoot, value);
	}

	void Delete(const T &value)
	{
		_Remove(_m_pRoot, value);
	}

	std::string PreOrder()
	{
		std::string strRet = _PreOrder(_m_pRoot);
		if (boost::algorithm::ends_with(strRet, " "))
		{
			boost::algorithm::replace_last(strRet, " ", "");
		}
		return strRet;
	}

	std::string  InOrder()
	{
		std::string strRet = _InOrder(_m_pRoot);
		if (boost::algorithm::ends_with(strRet, " "))
		{
			boost::algorithm::replace_last(strRet, " ", "");
		}
		return strRet;
	}

	std::string  PostOrder()
	{
		std::string strRet = _PostOrder(_m_pRoot);
		if (boost::algorithm::ends_with(strRet, " "))
		{
			boost::algorithm::replace_last(strRet, " ", "");
		}
		return strRet;
	}

	size_t  Height(const AVLTreeNode<T> *pNode)
	{
		if (nullptr == pNode) return 0;
		size_t nRightHeight =  1 + Height(pNode->pRight);
		size_t nLeftHeight = 1 + Height(pNode->pLeft);
		return std::max(nRightHeight, nLeftHeight);
	}


	void Destroy()
	{
		_Destroy(_m_pRoot);
	}


protected:


	std::string  StrFormat(const T &value)
	{
		std::string strRet;
		std::stringstream  ss;
		ss << value << " ";
		strRet += ss.str();
		return strRet;
	}


	std::string _PreOrder(AVLTreeNode<T> *pNode )
	{
		if (nullptr == pNode) return std::string();

		std::string strRet;
		strRet += StrFormat(pNode->data);
		strRet += _PreOrder(pNode->pLeft);
		strRet += _PreOrder(pNode->pRight);
		return strRet;
	}

	std::string  _InOrder(AVLTreeNode<T> *pNode)
	{
		if (nullptr == pNode) return std::string();

		std::string strRet;
		strRet += _InOrder(pNode->pLeft);
		strRet += StrFormat(pNode->data);
		strRet += _InOrder(pNode->pRight);
		return strRet;
	}

	std::string  _PostOrder(AVLTreeNode<T> *pNode)
	{
		if (nullptr == pNode) return std::string();


		std::string strRet;
		strRet += _PostOrder(pNode->pLeft);
		strRet += _PostOrder(pNode->pRight);
		strRet += StrFormat(pNode->data);
		return strRet;
	}


	//后序遍历释放空间
	void _Destroy(AVLTreeNode<T> * pNode) 
	{
		if (nullptr == pNode)
			return;
		_Destroy(pNode->pLeft);
		_Destroy(pNode->pRight);

		delete pNode;
		pNode = nullptr;
	}

	size_t _Difference(AVLTreeNode<T> *pNode)
	{
		return Height(pNode->pLeft) - Height(pNode->pRight);
	}

	void _Insert(AVLTreeNode<T> * &pNode, const T &value)
	{
		if (nullptr == pNode)
		{
			pNode = new AVLTreeNode<T>();
			pNode->data = value;
			pNode->pRight = nullptr;
			pNode->pLeft = nullptr;
			return ;
		}

		if (value > pNode->data)
		{
			_Insert(pNode->pRight, value);

			//进行平衡调整
			_Balance(pNode);
		}
		else
		{
			_Insert(pNode->pLeft, value);

			//进行平衡调整
			_Balance(pNode);
		}
	}



	//LL 型 调整,  单旋转,   右旋

	/*
	单旋转
	LL型   右旋

	  A
	 /
	B           --右旋-->       B
   /                           / \
  X(新插入的)                 X   A


  一般形式(插入X):

             A                                  B
	      /     \                            /     \
	     B       [#]                       [*]      A 
	   /  \      [#]        ----->         [*]    /   \
	 [*]   [$]   [#]                      /     [$]    [#] 
	 [*]   [$]                          [X]     [$]    [#]
	/                                                  [#]
  [X]


  */
	void LL_Adjust(AVLTreeNode<T> * &pNode)
	{
		AVLTreeNode<T> *pTmp = pNode->pLeft;
		pNode->pLeft = pTmp->pRight; //A接管B的右子树
		pTmp->pRight = pNode;

		pNode = pTmp;
	}



	/**
	单旋转

	RR型   左旋

	A
	 \
	  B              --左旋-->        B
	   \                             / \
	    X(新插入的)                 A   X


	一般形式(插入X):

	       A                                 B
	     /   \                            /     \
      [#]     B                          A       [$] 
	  [#]    /  \         --->         /   \     [$]
	  [#]  [*]   [$]                 [#]   [*]      \
		   [*]   [$]                 [#]   [*]      [X]
				   \                 [#]
				   [X]

	*/
	void RR_Adjust(AVLTreeNode<T> * &pNode)
	{
		AVLTreeNode<T> *pTmp = pNode->pRight;
		pNode->pRight = pTmp->pLeft; // A接管B的左子树
		pTmp->pLeft = pNode;
		pNode = pTmp;
	}



	/*
	双旋转

	LR型   先左旋  , 再右旋

	 A                             A
	/                             /
   B              --左旋-->      X            --右旋-->      X
	\                           /                           / \
	 X(新插入)                 B                           B   A


	*/
	void LR_Adjust(AVLTreeNode<T> *  &pNode)
	{
		RR_Adjust(pNode->pLeft);
		LL_Adjust(pNode);
	}



	/*
	双旋转

	RL型    先右旋, 再左旋

	A                           A
	 \                           \
	  B            --右旋-->      X           --左旋-->      X
	 /                             \                        / \
	X(新插入)                       B                      A   B

	*/

	void RL_Adjust(AVLTreeNode<T> * &pNode)
	{
		LL_Adjust(pNode->pRight);
		RR_Adjust(pNode);
	}


	void _Balance(AVLTreeNode<T> * &pNode)
	{
		if (nullptr == pNode) return;

		//求平衡因子(左右子树的高度差)
		int iBalanceFactor = _Difference(pNode);

		// LL型 或 LR型
		if (iBalanceFactor > 1)  
		{
			if (1 == _Difference(pNode->pLeft))
			{
				LL_Adjust(pNode);
			}
			else 
			{
				LR_Adjust(pNode);
			}
		}
		//RR型  或 RL型
		else if(iBalanceFactor < -1) 
		{
			if (-1 == _Difference(pNode->pRight)) 
			{
				//RR
				RR_Adjust(pNode);
			}
			else 
			{
				//RL
				RL_Adjust(pNode);
			}
		}
		//符合平衡条件
		else return;
	}



	//删除元素, 可以参考  BinarySearchTree的 remove方法
	//删除元素后需要进行平衡操作,以保持平衡性质
	void _Remove(AVLTreeNode<T> * &pNode, const T& value)
	{
		if (nullptr == pNode)
		{
			return;
		}
		else if (pNode->data < value)
		{
			_Remove(pNode->pRight, value);
		}
		else if (pNode->data > value)
		{
			_Remove(pNode->pLeft, value);
		}
		else // 找到了
		{
			//如果有左右子树
			if (nullptr != pNode->pLeft && nullptr != pNode->pRight)
			{
				//找到右子树中最小的节点
				AVLTreeNode<T> *pTmp = pNode->pRight;
				for (; nullptr != pTmp->pLeft; pTmp = pTmp->pLeft) {};

				pNode->data = pTmp->data;
				_Remove(pNode->pRight, pTmp->data);
			}
			else if (nullptr == pNode->pLeft)
			{
				AVLTreeNode<T> *pTmp = pNode;
				pNode = pNode->pRight;
				//*pNode = *(pNode->pRight); //如果函数参数是  指针类型, 而不是指针引用类型, 则需要进行拷贝
				delete pTmp;
			}
			else if (nullptr == pNode->pRight)
			{
				AVLTreeNode<T> *pTmp = pNode;
				pNode = pNode->pLeft;
				*pNode = *(pNode->pLeft);
				delete pTmp;
			}
		}

		//平衡操作
		_Balance(pNode);
	}


};

测试用例

// AVLTree.cpp : 定义控制台应用程序的入口点。
//


#include "stdafx.h"
#include<iostream>
#include<cstdio>
#include<sstream>
#include<algorithm>
#include <string>



#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string>
#include <algorithm>
#include <vector>
#include <list>
#include <map>

using namespace std;



#include "AVLTree.hpp"
#include "avl_tree_ref.hpp"

#define BOOST_TEST_MAIN
#include <boost/test/included/unit_test.hpp>




BOOST_AUTO_TEST_SUITE(test)

//
//BOOST_AUTO_TEST_CASE(test_avl_tree)
//{
//	avl_tree avl;
//
//	r = avl.insert(r, 3);
//	r = avl.insert(r, 2);
//	r = avl.insert(r, 1);
//
//
//	avl.inorder(r);
//	std::cout << std::endl;
//}
//


BOOST_AUTO_TEST_CASE(test_AVLTree)
{
	AVLTree<int>  tree;
	tree.Insert(20);
	tree.Insert(13);
	tree.Insert(7); //LL型 
	tree.Insert(17);

	BOOST_REQUIRE_EQUAL(tree.InOrder(), std::string("7 13 17 20"));
	BOOST_REQUIRE_EQUAL(tree.PreOrder(), std::string("13 7 20 17"));
	BOOST_REQUIRE_EQUAL(tree.PostOrder(), std::string("7 17 20 13"));

	tree.Insert(15); //LL型 


	BOOST_REQUIRE_EQUAL(tree.InOrder(), std::string("7 13 15 17 20"));
	BOOST_REQUIRE_EQUAL(tree.PreOrder(), std::string("13 7 17 15 20"));
	BOOST_REQUIRE_EQUAL(tree.PostOrder(), std::string("7 15 20 17 13"));


	tree.Insert(14); //LL型  , 再 RR型

	BOOST_REQUIRE_EQUAL(tree.InOrder(), std::string("7 13 14 15 17 20"));
	BOOST_REQUIRE_EQUAL(tree.PreOrder(), std::string("15 13 7 14 17 20"));
	BOOST_REQUIRE_EQUAL(tree.PostOrder(), std::string("7 14 13 20 17 15"));


	tree.Insert(18); //RL型(17不符合平衡条件)
	BOOST_REQUIRE_EQUAL(tree.InOrder(), std::string("7 13 14 15 17 18 20"));
	BOOST_REQUIRE_EQUAL(tree.PreOrder(), std::string("15 13 7 14 18 17 20"));
	BOOST_REQUIRE_EQUAL(tree.PostOrder(), std::string("7 14 13 17 20 18 15"));


	tree.Insert(4); //不需调整
	tree.Insert(5);  //LR型
	BOOST_REQUIRE_EQUAL(tree.InOrder(), std::string("4 5 7 13 14 15 17 18 20"));
	BOOST_REQUIRE_EQUAL(tree.PreOrder(), std::string("15 13 5 4 7 14 18 17 20"));
	BOOST_REQUIRE_EQUAL(tree.PostOrder(), std::string("4 7 5 14 13 17 20 18 15"));


}


BOOST_AUTO_TEST_CASE(test_AVLTree_Remove)
{
	AVLTree<int>  tree;
	tree.Insert(10);
	tree.Insert(9);
	tree.Insert(11);
	tree.Insert(8);

	BOOST_REQUIRE_EQUAL(tree.InOrder(), std::string("8 9 10 11"));
	BOOST_REQUIRE_EQUAL(tree.PreOrder(), std::string("10 9 8 11"));
	BOOST_REQUIRE_EQUAL(tree.PostOrder(), std::string("8 9 11 10"));

	tree.Delete(10);

	BOOST_REQUIRE_EQUAL(tree.InOrder(), std::string("8 9 11"));
	BOOST_REQUIRE_EQUAL(tree.PreOrder(), std::string("9 8 11"));
	BOOST_REQUIRE_EQUAL(tree.PostOrder(), std::string("8 11 9"));

}




BOOST_AUTO_TEST_SUITE_END()
youngqqcn
关注
专栏目录
AVLtree_c_avl_平衡二叉树_avltree_
10-02
综上所述，"AVLtree_c_avl_平衡二叉树_avltree_"这个项目可能是用C语言实现了一个AVL树的数据结构，并提供了对树的增删改查操作，同时具备用户友好的交互界面。这个项目对于理解和实践AVL树的概念、操作和性能优化...
STL中的平衡二叉树（multiset set）
最爱晴天和自己的博客
08-04 2723
multiset set multimap map#include &lt;set&gt; //使用multiset和set需要此头文件  可在增加和删除数据的基础上查找数据。 multiset用法 multiset&lt;T&gt; st;   定义了一个multiset变量st，st里面可以存放T类型的数据，并且能自 动排序。开始st为空    size()  返回容器中元素的数...
二叉树、平衡二叉树、红黑树、B-树、B+树、B*树、T树之间的详解和比较
随意的风的专栏
01-18 6445
====================================================|| 欢迎讨论技术的可以相互加微信：windgs (请备注csdn+xx职业) ====================================================|| 一、二叉树-BST (binary search/sort tree) 二叉树又名二叉查找/搜索...
平衡二叉查找树（AVL）的查找、插入、删除
lpp0900320123的专栏
09-18 1万+
1.平衡二叉查找树
STL源码笔记（18）—平衡二叉树AVL（C++封装+模板）
上善若水
05-20 1万+
平衡二叉树AVL 简介，C++ 封装与模板的实现
平衡树——自平衡二叉树(Balanced Tree - AVL Tree)
UoM_XiaoShuaiShuai的博客
06-10 1622
平衡树——自平衡二叉树(Balanced Tree - AVL Tree)定义(Definition) An AVL tree is a self-balancing binary search tree. It was named after its two inventors: Georgy Adelson-Velsky and Evgenii Landis. Recall that we d
03平衡二叉树_AVLTree.rar_03平衡二叉树_AVLTree_大话数据结构_平衡二叉树
09-21
在"03平衡二叉树_AVLTree.c"这个文件中，应该包含了C语言实现AVL树的代码，包括节点结构定义、插入、删除和查找等基本操作，以及相应的旋转函数。通过阅读和理解这段代码，可以深入学习AVL树的内部工作原理和操作...
平衡二叉树AVL操作模板
09-04
2. 树结构：AVLTree * root：根节点 * hgt：树的高度 * size：树中不重复节点的数量 操作 1. 插入操作：_insert * 将新的节点插入树中，并保持树的平衡状态 2. 中序遍历：_mid_travel * 将树的节点按照中序遍历...
AVL tree 平衡二叉树
03-17
AVL tree的数据结构例程，参考《数据结构与算法分析——C语言版》，书上代码整理成为一个可运行C程序文件
AVLTree 平衡二叉树c++实现
06-26
AVL树是一种自平衡的二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis在1962年提出，因此得名AVL树。这种数据结构在查找、插入和删除操作上的平均时间复杂度都是O(log n)，这得益于其严格的平衡性质。AVL树的主要...
boost::intrusive::avltree_algorithms用法的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-09 260
boost::intrusive::avltree_algorithms用法的测试程序实现功能C++实现代码 实现功能 boost::intrusive::avltree_algorithms用法的测试程序 C++实现代码 #include <boost/intrusive/avltree_algorithms.hpp> #include <cassert> struct my_node { my_node(int i = 0) : int_(i) {}
索引 ----- 二叉树、平衡二叉树、b-tree、b+tree详解
qq_36098284的博客
05-03 1万+
本文是转载+自我梳理主要讲的是索引中使用树这种数据结构是怎么存储的。以及从二叉树开始的4种树的应用。我个人认为参考价值最大的就是b+tree和b-tree都是具体怎么存数据的（相当于优化部分）B+树索引是B+树在数据库中的一种实现，是最常见也是数据库中使用最为频繁的一种索引。B+树中的B代表平衡（balance），而不是二叉（binary），因为B+树是从最早的平衡二叉树演化而来的。在讲B+树之前...
vs2015(或vs2017) 不能新建C++项目
热门推荐
yqq1997的博客
12-24 1万+
前段时间安装 nodejs的一些模块&amp;nbsp;, 添加了环境变量&amp;nbsp;&amp;nbsp;VCTargetsPath, 并设置为 C:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\v140, 并添加到了系统path中.&amp;nbsp;&amp;nbsp;&amp;nbsp;结果导致vs2015不能新建c++项目(创建出来的项目没有文件,只有&quot;外部依赖&quo
qt+vs2017 使用 vs2015编译报错 'type_traits': No such file or directory
yqq1997的博客
12-09 5908
Win7下 qt + vs2017 使用 vs2015编译报错 'type_traits': No such file or directory “cl”不是内部或外部命令，也不是可运行的程序或批处理文件 问题原因: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat 中有两行检查命令, 检查命令失败导致...
linux安装多个版本gcc和g++
yqq1997的博客
01-25 1475
https://askubuntu.com/questions/26498/how-to-choose-the-default-gcc-and-g-version 删除update-alternatives中旧的gcc和g++配置: sudo update-alternatives --remove-all gcc sudo update-alternatives --remove-all g++ 安装 It seems that both gcc-4.3 and gcc-4.4 are insta
__thread 变量使用
yqq1997的博客
11-29 1152
__thread 使用规则: 只能修饰POD类型, 不能修饰class类型, 因为无法自动调用构造函数和析构函数 __thread可以修饰全局变量和函数内的静态变量, 但是不能修饰函数的局部变量或者class的普通成员变量. #include <stdio.h> #include <pthread.h> #include <unistd.h> #include <string.h> #include <string> #define THRE
开始使用c++20
yqq1997的博客
01-25 847
这里包含了各编译对c++标准的实现进度: https://en.cppreference.com/w/cpp/compiler_support 这里以g++10为例, 关于怎么安装g++10可以参考这篇文章 #include <bit> #include <iostream> int main() { if constexpr (std::endian::native == std::endian::big) { std::cout <<
C++20-协程(coroutine)
yqq1997的博客
02-05 823
参考: https://en.cppreference.com/w/cpp/language/coroutines Coroutines A coroutine is a function that can suspend execution to be resumed later. Coroutines are stackless: they suspend execution by returning to the caller and the data that is required to res
MongoDB简单使用(C语言)
yqq1997的博客
05-27 709
#include <bson.h> #include <mongoc.h> #include <stdio.h> int main (int argc, char *argv[]) { mongoc_client_t *client; mongoc_collection_t *collection; bson_error_t error; bson_oid_t oid; bson_t *doc; mongoc_init (); client = m
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值