AVL平衡树实现

最新推荐文章于 2024-10-05 19:25:32 发布
最新推荐文章于 2024-10-05 19:25:32 发布
阅读量607 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： null string delete tree struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LBO4031/article/details/6964064
 
#ifndef BELANCETREE_INCLUDED
#define BELANCETREE_INCLUDED
#include <string>
//#include <cstdlib>
using namespace std;
#define ERROR 0
#define LH +1 //左高
#define RH -1 //右高
#define EH 0  //等高
//#define __BINARY_TREE  //是否使用二叉树
#define __STRING_DATA   //data是否为string类型

typedef string BsTreeType;

struct BsTreeNode
{
     short bf; //节点平衡因子
     struct BsTreeNode *lchild, *rchild;
     BsTreeType data;
};

typedef BsTreeNode Node;
typedef Node* PNode;

class BslanceTree
{
   public:
    inline BslanceTree(void);
    //排序二叉树
#ifdef __BINARY_TREE
    inline bool AddNode(const BsTreeType & data); //非字符串型
    inline bool delNode(const BsTreeType & data);
    inline bool FindNode(const BsTreeType & data);
    inline bool TraverBsTree(const PNode & pnode);
#endif
    //bbst平衡二叉树
	bool   InsertAvl(const BsTreeType & data);
    inline PNode & GetRoot(void);
	bool   DelAvl(const BsTreeType & data);
    inline ~BslanceTree(void);

   protected:

    inline bool GR(const string & sdata, const string & ddata);
    inline bool EQ(const string & sdata, const string & ddata);
#ifndef __STRING_DATA
    inline bool GR(const BsTreeType & sdata, const BsTreeType & ddata);
    inline bool EQ(const BsTreeType & sdata, const BsTreeType & ddata);
#endif
    inline void CleanTree(PNode & pnode);
           bool DelAvlNode(PNode & pnode);
		   bool InsertAVL(PNode & pnode);
    inline void RightBalance(PNode & pnode);
    inline void  LeftBalance(PNode & pnode);
    inline void     L_Rotate(PNode & pnode);
    inline void     R_Rotate(PNode & pnode);
  private:
#ifdef __BINARY_TREE
	PNode m_pnode;
#endif

    PNode m_Root;
	BsTreeType data;
	bool hight_change;
};

inline BslanceTree::BslanceTree(void)
{
    m_Root =  NULL;
#ifdef __BINARY_TREE
	m_pnode = NULL;
#endif

}

////////////////////////////////////////////////////////////////////////
#ifdef __BINARY_TREE

inline bool BslanceTree::AddNode(const BsTreeType & data)
{
   PNode pnode = new Node;
   if (pnode == NULL)
      return false;
   pnode->lchild = NULL;
   pnode->rchild = NULL;
   pnode->data   = data;

   if (m_Root == NULL)
    {
        m_Root = pnode;
        return true;
    }

   m_pnode = NULL;
   if ( BslanceTree::FindNode(data) ) //node have been create
      return true;
   if (m_pnode == NULL)
      return false;
   if (BslanceTree::GR(m_pnode->data, data))
      m_pnode->rchild = pnode;
   else
      m_pnode->lchild = pnode;
   return true;
}

inline bool BslanceTree::FindNode(const BsTreeType & data)
{//not string type
    m_pnode    = m_Root;
    PNode next = m_pnode;
    while (next)
    {
        if (BslanceTree::EQ(next->data, data))
           return true;
        m_pnode = next;
        if (BslanceTree::GR(next->data, data))
           next = next->rchild; //right big and left small
        else
           next = next->lchild;
    }
    return false;
}

inline bool BslanceTree::delNode(const BsTreeType & data)
{
   if ( BslanceTree::FindNode(data) )
   {
       if (m_pnode == NULL)
          return false;
       if (m_pnode->lchild == NULL)
       {
           if (m_pnode->rchild != NULL)
		   {
			   PNode p = m_pnode;
               m_pnode = m_pnode->rchild;
			   delete p;
			   p = NULL;
		   }
           else
		   {
             delete m_pnode;
             m_pnode = NULL;
		   }
           return true;
       }
       else
       {
           if (m_pnode->rchild == NULL)
           {
		     PNode p = m_pnode;
             m_pnode = m_pnode->lchild;

             delete p;
             p = NULL;
           }
           else
           {
			  PNode pre = m_pnode->lchild;
			  while (pre->rchild)
				pre = pre->rchild;
			  if (pre == NULL)
				  return false;
			  m_pnode->data = pre->data;//交换值
			  delete pre;
			  pre = NULL;
           }//else
         return true;
       }
   }
   return false;
}


inline bool BslanceTree::TraverBsTree(const PNode & pnode)
{
    if (pnode != NULL)
    {
      BslanceTree::TraverBsTree(pnode->lchild);
	  cout << "data : " << pnode->data << endl;
      BslanceTree::TraverBsTree(pnode->rchild);
    }
}

#endif////////////__BINARY_TREE//////////////////////////

#ifndef __STRING_DATA
inline bool BslanceTree::GR(const BsTreeType & sdata, const BsTreeType & ddata)
{
    return sdata > ddata ? true : false;
}

inline bool BslanceTree::EQ(const BsTreeType & sdata, const BsTreeType & ddata)
{
    return sdata == ddata ? true : false;
}
#endif
inline bool BslanceTree::GR(const string & sdata, const string & ddata)
{
    if (!sdata.size() || !ddata.size())
       exit(ERROR);
    return strcmp(sdata.c_str(), ddata.c_str()) > 0 ? true : false;
}

inline bool BslanceTree::EQ(const string & sdata, const string & ddata)
{
    if (!sdata.size() || !ddata.size())
       exit(ERROR);
    return strcmp(sdata.c_str(), ddata.c_str()) == 0 ? true : false;
}

inline BslanceTree::~BslanceTree(void)
{
    BslanceTree::CleanTree(m_Root);
}

inline void BslanceTree::CleanTree(PNode & pnode)
{
    if (pnode != NULL)
    {
        BslanceTree::CleanTree(pnode->lchild);
        BslanceTree::CleanTree(pnode->rchild);
        delete pnode;
        pnode = NULL;
    }
}

bool BslanceTree::InsertAVL(PNode & pnode)
{
    if (pnode == NULL)
    {
      pnode = new Node;
      if (pnode == NULL)
        exit(ERROR);
      pnode->data = BslanceTree::data;
      pnode->lchild = pnode->rchild = NULL;
      pnode->bf = EH, BslanceTree::hight_change = true;
    }
    else
    {
        if ( BslanceTree::EQ(pnode->data, BslanceTree::data) )
        {//节点已经存在
            BslanceTree::hight_change = false;
            return false;
        }

        if ( BslanceTree::GR(BslanceTree::data, pnode->data) )
        {//插入到右子树中
            if ( !BslanceTree::InsertAVL(pnode->rchild) )
               return false;
            if (BslanceTree::hight_change)
            {//已经插入到右子树中而且树已经长高
                switch (pnode->bf)
                {
                    case LH:  //原左子树比右子树高，现在等高
                        pnode->bf = EH; BslanceTree::hight_change = false; break;
                    case EH:  //原本左右子树等高，现在右子树比左子树要高, 所以树长高
                        pnode->bf = RH; BslanceTree::hight_change = true; break;
                    case RH:  //原来右子树比左子树要高，需要作平衡处理
                        BslanceTree::RightBalance(pnode);
                        BslanceTree::hight_change = false; break;//bf的变化由函数RightBalance(pnode)说了算
                }//switch
            }//if_t
        }//if_B
        else
        {//插入到左子树中
            if ( !BslanceTree::InsertAVL(pnode->lchild) )
               return false;
            if (BslanceTree::hight_change)
            {
                switch (pnode->bf)
                {
                    case LH:  //原来左子树比右子树高，需要作平衡处理
                        BslanceTree::LeftBalance(pnode);
                        BslanceTree::hight_change = false; break;//bf的变化由函数LeftBalance(pnode)说了算
                    case EH:  //原来右子树与左子树等高，现在左子树长高，所以树长高
                        pnode->bf = LH; BslanceTree::hight_change = true; break;
                    case RH:  //原来右子树比左子树要高，现在要变成等高
                        pnode->bf = EH; BslanceTree::hight_change = false; break;
                }//switch
            }//if_t
        }//else
    }//else
    return true;
}

inline void BslanceTree::RightBalance(PNode & pnode)
{//右平衡处理
    PNode rc = pnode->rchild;
    switch (rc->bf)
    {
        case RH: //新插入的节点在pnode右孩子的右子树，要作单左旋转处理
            pnode->bf = rc->bf = EH;
            BslanceTree::L_Rotate(pnode); break;
		case EH: // new
			pnode->bf = RH, rc->bf = LH;
			BslanceTree::L_Rotate(pnode); break;
        case LH: //新插入的节点在右孩子的左子树上，要作双旋转处理
            PNode ld = rc->lchild;  //ld指向pnode右孩子的左子树的根
            switch (ld->bf)
            {
                case LH: pnode->bf = EH; rc->bf = RH; break;
                case EH: pnode->bf = EH; rc->bf = EH; break;
                case RH: pnode->bf = LH; rc->bf = EH;
            }//sw_ld
            ld->bf = EH;
            BslanceTree::R_Rotate(pnode->rchild);
            BslanceTree::L_Rotate(pnode);
    }//sw_ld
}

inline void BslanceTree::LeftBalance(PNode & pnode)
{//左平衡处理
    PNode lc = pnode->lchild;
    switch (lc->bf)
    {
        case LH: //新插入的节点在左子树，需要单右旋转处理
            pnode->bf = lc->bf = EH;
            BslanceTree::R_Rotate(pnode); break;
		case EH: // new
			pnode->bf =LH, lc->bf = RH;
			BslanceTree::R_Rotate(pnode); break;
        case RH: //新插入的节点在右子树，要作双旋转处理
            PNode rd = lc->rchild; //rd为pnode左孩子的右子树的根
            switch (rd->bf)
            {
                case LH: lc->bf = EH; pnode->bf = RH; break;
                case EH: lc->bf = pnode->bf = EH; break;
                case RH: lc->bf = LH; pnode->bf = EH; break;
            }
            rd->bf = EH;
            BslanceTree::L_Rotate(pnode->lchild);
            BslanceTree::R_Rotate(pnode);
    }//sw_lc
}

inline void BslanceTree::L_Rotate(PNode & pnode)
{//向左旋转,pnode最终还是指向更新后的根节点
    PNode rc = pnode->rchild;
    pnode->rchild = rc->lchild;
    rc->lchild = pnode;
    pnode = rc;  //更新根节点
}

inline void BslanceTree::R_Rotate(PNode & pnode)
{//向右旋转,pnode最终还是指向更新后的根节点
    PNode lc = pnode->lchild;
    pnode->lchild = lc->rchild;
    lc->rchild = pnode;
    pnode = lc;
}

bool BslanceTree::DelAvlNode(PNode & pnode)
{
	if (pnode == NULL)
		return false;
	if ( BslanceTree::EQ(pnode->data, BslanceTree::data) )
	{//delete node
		BslanceTree::hight_change = true; //树变矮
		if (pnode->lchild == NULL)
		{
			if (pnode->rchild != NULL)
				pnode = pnode->rchild;
			else
			{
				delete pnode;
				pnode = NULL;
			}
			return true;
		}
		else
		{
			if (pnode->rchild == NULL)
				pnode = pnode->lchild;
			else
			{//查找前驱
				PNode pre = pnode->lchild;
				while (pre->rchild)
					pre = pre->rchild;

				//交换值
				pnode->data = pre->data;
				BslanceTree::data = pre->data;

				if ( !BslanceTree::DelAvlNode(pnode->lchild) )
					return false;
				if (BslanceTree::hight_change)
				{//变矮
					switch (pnode->bf)
					{
					case LH: //较高的子树被缩短
						pnode->bf = EH;
						cout << "371\n";
						BslanceTree::hight_change = true; break;
						break;
					case EH: //原来平等
						pnode->bf = RH;
						cout << "376\n";
						BslanceTree::hight_change = false; break;
					case RH: //较低的子树被缩短
						if (pnode->rchild != NULL)
							if (pnode->rchild->bf == EH)
								BslanceTree::hight_change = false;
						BslanceTree::RightBalance(pnode); 
						cout << "383\n";
						break;
					}//sw_pn
				}
			}//else
		 return true;
		}//else
	}//if_Bs
	//m_ptemp_node = pnode; //保存父节点
	if ( BslanceTree::GR(BslanceTree::data, pnode->data) )
	{//右子树
		if ( !BslanceTree::DelAvlNode(pnode->rchild) )
			return false;
		if (BslanceTree::hight_change)
		{//变矮
			switch (pnode->bf)
			{
			case LH: //较低的子树被缩短
				if (pnode->lchild != NULL)
					if (pnode->lchild->bf == EH)
						BslanceTree::hight_change = false;
				BslanceTree::LeftBalance(pnode);
				cout << "405\n";
				break;
			case EH: //原来平等
				pnode->bf = LH;
				cout << "409\n";
				BslanceTree::hight_change = false; break;
			case RH: //较高的子树被缩短
				pnode->bf = EH;
				cout << "413\n";
				BslanceTree::hight_change = true; break;
			}//sw_pn
		}
	}
	else
	{
		if ( !BslanceTree::DelAvlNode(pnode->lchild) )
			return false;
		if (BslanceTree::hight_change)
		{//变矮
			switch (pnode->bf)
			{
			case LH: //较高的子树被缩短
				pnode->bf = EH;
				cout << "403\n";
				BslanceTree::hight_change = true; break;
				break;
			case EH: //原来平等
				pnode->bf = RH;
				cout << "409\n";
				BslanceTree::hight_change = false; break;
			case RH: //较低的子树被缩短
				if (pnode->rchild != NULL)
					if (pnode->rchild->bf == EH)
						BslanceTree::hight_change = false;
				BslanceTree::RightBalance(pnode); 
				cout << "413\n";
				break;
			}//sw_pn
		}
	}

	return true;
}


inline PNode & BslanceTree::GetRoot(void)
{
    return m_Root;
}

bool BslanceTree::DelAvl(const BsTreeType & data)
{
	BslanceTree::data = data;
	BslanceTree::hight_change = true;
	if ( !BslanceTree::DelAvlNode(m_Root) )
		return false;
	return true;
}

bool BslanceTree::InsertAvl(const BsTreeType & data)
{
	BslanceTree::data = data;
	BslanceTree::hight_change = true;
	if ( !BslanceTree::InsertAVL(m_Root) )
		return false;
	return true;
}

#endif // BELANCETREE_INCLUDED

平衡二叉树(AVL)平衡调整
Justdoforever的博客
03-28 3130
文章目录一、AVL树简介二、AVL树相关概念三、调整第一类：LL，RR第二类，LR，RL 一、AVL树简介 AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树（Self-Balancing Binary Search Tree,简称平衡二叉树）。 平衡二叉树定义(AVL)：它或者是一颗空树，或者具有以下性质的二叉排序树：它的左子树和右子树的深度之差(平衡因子)的绝对值不超过1，且它的左子树和右子树都是一颗平衡二叉树。 一棵
【C++】平衡二叉树(AVL树)的实现
lgr669877aqa的博客
06-21 988
_kv(kv),_bf(0){}// 使用三叉链方便后续处理，但要记得维护// 保存键值对int _bf;// 平衡因子parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR当subR的平衡因子为1时，执行左单旋当subR的平衡因子为-1时，执行右左双旋parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL当subL的平衡因子为-1是，执行右单旋当subL的平衡因子为1时，执行左右双旋。
AVL平衡二叉树
百味皆苦的博客
02-15 890
目录 什么是平衡二叉树，平衡因子  实现AVL树  基于AVL的映射map（接口在以前博客中） 基于AVL的集合set（接口在以前博客中）   什么是平衡二叉树，平衡因子          实现AVL树 package com.suanfa.AVLTree; import java.util.ArrayList; /** * AVL树，平衡二叉树，优化二分搜...
avl平衡树
wejboke626的博客
12-24 321
一、本博客主要内容： 1、平衡树的概念，性质 2、平衡树实现 1、平衡树节点介绍 2、构造/拷贝构造/运算符重载/树拷贝 3、插入节点 4、删除节点 5、旋转 ...
AVL平衡树及插入操作的C语言实现
06-21
AVL平衡树是一种自平衡的二叉搜索树（Binary Search Tree），由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名AVL树。在AVL树中，任何节点的两个子树的高度最大差别不超过1，这确保了树的平衡性，从而...
avl.rar_avl_平衡树
09-20
AVL树是一种自平衡二叉查找树（BST），...为了理解并使用这个AVL树实现，你需要阅读和理解源代码，以及查看或遵循文本文件中的指示。理解AVL树的工作原理对于学习数据结构和算法，尤其是树形结构的优化，是非常有益的。
AVL_tree.zip_AVL树_avl_tree_avl树左右子树_平衡树_高度平衡树
09-21
如果插入操作导致某个节点的平衡因子（左子树高度减去右子树高度）绝对值超过1，就需要进行旋转操作来重新平衡树。常见的旋转类型有四种：左旋、右旋、左右旋和右左旋。 - **左旋**：当插入操作导致节点的右子树过...
红黑树及AVL树常见平衡树实现
01-16
删除操作则更为复杂，可能需要找到替换节点，重新平衡树，并处理节点颜色变化。 在实际应用中，选择红黑树还是AVL树主要取决于对查找速度和插入删除效率的需求。如果查找操作更为频繁，而插入删除操作相对较少，AVL...
AVL平衡树（java实现）
小虫的博客
03-06 124
public class AVLTree&lt;T extends Comparable&lt;? super T&gt;&gt; { /** * 根节点 */ private AvlNode&lt;T&gt; root; /** * 插入 * * @timestamp Mar 5, 2016 6:31:53 PM * @param x ...
AVL如何保持平衡
liushanwu635的博客
03-26 557
二叉树遍历子节点 根据二叉树的先序遍历和中序遍历，或者根据后序遍历和中序遍历可以确定唯一确定一颗二叉树。 但是根据前序遍历和后序遍历是无法唯一确定一颗二叉树的。 如何判断一个二叉树对应的树林有多少棵树呢 先画出这颗二叉树 将这颗二叉树的根节点和左子树截下来形成一颗树，剩下的部分继续按照以上方法进行切割。 最后知道剩下的子树没有右子树了才完毕。 AVL平衡二叉树 首先找到要插入的值应该插入的具体位置
平衡二叉树——AVl树
最新发布
qq_34434522的博客
10-05 867
从插入节点的父节点开始，逐级向上检查每个祖先节点的平衡因子（Balance Factor, BF），即左子树高度减去右子树高度（BF = height(left) - height(right)），或者相反。AVL树是一种二叉搜索树，意味着每个节点都有一个键值，左子树的所有节点值小于该节点的值，右子树的所有节点值大于该节点的值。AVL树在插入或删除节点时，通过旋转操作来保持树的平衡，以确保所有基本操作的时间复杂度为 O(log n)。节点的高度是其左子树和右子树高度的最大值加一。
平衡二叉树AVL详解
渴望，就奋力追寻...
03-16 2279
一、平衡二叉树的定义 平衡二叉树（Balanced Binary Tree）又被称为AVL树，它且具有以下性质： （1）它是一棵空树或它的左右两个子树的高度差的绝对值不超过1； （2）并且左右两个子树都是一棵平衡二叉树。 把二叉树的每个节点的左子树减去右子树定义为该节点的平衡因子。二叉平衡树的平衡因子只能是1、0或者-1。 需要注意的是，平衡二叉树是对二叉
平衡树详解之AVL
Vurteon的专栏
12-07 2313
前言：          本文介绍了AVL的插入和删除， 首先让我们想一下很简单的二分查找，其效率为O(lgn)，这是很好的，而大多数时候在数据的处理涉及到插入和删除，但是，线型表仅仅使用于查找，所以—依据二分查找性质的二叉排序树出现了，但是却出现了由于树的形状而影响查找效率的情况，导致可能会出现O(n)的情况，一般二叉树的查找复杂度是和深度有关，所以如果能够控制二叉排序树的形状，那么就能够控制
带你深入理解AVL(平衡二叉树)
m0_61227789的博客
10-10 214
AVL Tree 是一个“加上了额外的平衡条件的二叉搜索树”。其平衡条件的建立是为了确保整棵树的深度为O(logN)。直观上的最佳平衡条件是每个节点的左右子树有相同的高度，但这太严苛，我们很难插入新元素而又保持这样的平衡条件。AVL Tree 于是退而求其次，要求任何节点的左右子树高度相差最多1。这是一个较弱的条件，但仍能够保证“对数深度”平衡状态。如下图所示的是一个AVL Tree，插入了节点11之后，灰色节点违法了AVL Tree的平衡条件。
AVL平衡搜索二叉树
magiclyj的博客
07-13 319
能学到这里，相信你已经对树有了基本的认识，了解了输的结构以及特殊树–二叉树有了初步的认识，在AVL树之前你可能学过搜索二叉树，它主要是为了方便数据搜索建立的二叉树，以根节点作为分水岭，将数据和根节点比较来决定数据放在根节点的左右子树中，在和子树中的节点中的数据进行比较决定最终数据时节点的左右子节点。 而这里的平衡搜索二叉树不仅做到了搜索二叉树的功能，它还大大降低了查找节点的深度，保证了整个
数据结构----AVL平衡树----AVL平衡树的基本操作
crosnken的博客
03-29 1163
一、二叉查找树 我们先来讲讲二叉查找树。 大家应该听说过二分查找吧，二分查找是对一个有序序列的快速查找，时间复杂度为O(log2(n))， 但是二分查找也有它的缺点，当序列加入一个元素时，我们就需要对这个有序序列进行维护，要么就用sort()，要么就用插入排序（附带大量的数据移动），时间复杂度就会陡然提升。 于是就有了一种新的数据结构：二叉查找树！ 二叉查找树的运用比较灵活，支持插入O(log2(n))、查找O(log2(n))、删除和前驱后继的查询。
C++实现平衡树 AVL Tree 源码解析
在众多平衡树的实现中，AVL树（Adelson-Velsky和Landis tree）是最著名的自平衡二叉搜索树之一。AVL树的名称来自其发明者Georgy Adelson-Velsky和Evgenii Landis。 在AVL树中，任何节点的两个子树的高度最多相差1。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值