平衡二叉树的实现与遍历（全过程）

最新推荐文章于 2024-05-04 11:30:00 发布
最新推荐文章于 2024-05-04 11:30:00 发布
阅读量597 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hzx5200693/article/details/108804348
版权

平衡二叉树的实现：
代码实现过程踩过的坑总结：

  1. 把结构体定义成如下形式是不行的。(BitTree好像是二级指针不能放结构体里面)
    typedef struct BitNode{
    int data;
    int bf;
    BitTree left;
    BitNode* right;
    }BitNode,*BitTree;
  2. malloc只能赋给结构体指针，不能赋给结构体（一直以为结构体和数组一样，名字代表指针，所以会犯错）。
  3. 插入函数设计时，应该设计成InsertAVL(BitTree* T,int data,bool &taller)，这样不行：InsertAVL(BitTree T,int data,bool &taller)。函数在在进入函数后，相当于形参，回传不了。
//平衡二叉树的基本操作实现代码
#include<iostream>
#include<stack>
using namespace std;

//宏定义标识两边高度差，LH左边高，EH平衡，RH右边高
#define LH +1
#define EH 0
#define RH -1

//树节点定义
typedef struct BitNode{
    int data;
    int bf;
    BitNode* left;
    BitNode* right;
}BitNode,*BitTree;

//插入节点后左旋
void L_Rotate(BitTree* T){
    BitTree R=(*T)->right;
    (*T)->right=R->left;
    R->left=(*T);
    (*T)=R;
    return ;
}

//插入节点后右旋
void R_Rotate(BitTree* T){
    BitNode* L=(*T)->left;
    (*T)->left=L->right;
    L->right=(*T);
    (*T)=L;
    return ;
}

//T 的左边高，不平衡，使其平衡，右旋转，右旋转前先检查L->bf，
//如果为RH，L要先进行左旋转，使T->left->bf和T->bf一致
void LeftBalance(BitTree* T){
    BitTree L=(*T)->left;
    switch(L->bf){
        case LH:
            (*T)->bf=EH;
            L->bf=EH;
            R_Rotate(T);
            break;
        case RH:
            BitTree LR=L->right;
            switch (LR->bf)
            {
            case LH:
                (*T)->bf=RH;
                L->bf=EH;
                break;
            case EH:
                (*T)->bf=EH;
                L->bf=EH;
                break;
            case RH:
                (*T)->bf=EH;
                L->bf=LH;
                break;
            }
            LR->bf=EH;
            L_Rotate(&L);
            R_Rotate(T);
            break;
    }
}

//T 的右边高，不平衡，使其平衡，左旋转，左旋转前先检查R->bf,
//如果为LH，R要先进行右旋转，使T->left->bf和T->bf一致
void RightBalance(BitTree* T){
    BitTree R=(*T)->right;
    
    switch (R->bf)
    {
    case RH:
        (*T)->bf=R->bf=EH;
        L_Rotate(T);
        break;
    
    case LH:
        BitTree RL=R->left;
        switch (RL->bf)
        {
        case LH:
            (*T)->bf=EH;
            R->bf=RH;
            break;
        case EH:
            (*T)->bf=EH;
            R->bf=EH;
            break;
        case RH:
            (*T)->bf=LH;
            R->bf=EH;
            break;
        }
        RL->bf=EH;
        R_Rotate(&R);
        L_Rotate(T);
        break;
    }
}

//往平衡二叉树上插入结点
bool InsertAVL(BitTree* T,int data,bool &taller){
    if((*T)==NULL){//找到了插入的位置
        (*T)=(BitNode*)malloc(sizeof(BitNode));
        (*T)->data=data;
        (*T)->left=(*T)->right=NULL;
        (*T)->bf=EH;
        taller=true;
    }else{
        if(data==((*T)->data)){
            taller=false;
            return false;
        }
        if(data<((*T)->data)){
            if(!InsertAVL(&(*T)->left,data,taller)){
                taller=false;
                return false;           
            }
            if(taller){
                switch((*T)->bf){
                case LH:
                    LeftBalance(T);                 //插入后左边不平衡了，让其左平衡
                    taller = false;
                    break;
                case EH:
                    (*T)->bf = LH;
                    taller = true;
                    break;
                case RH:
                    (*T)->bf = EH;
                    taller = false;
                    break;
                }
            }
        }else{
            if(!InsertAVL(&(*T)->right,data,taller))     //树中有相同的结点
            {
                taller = false;
                return false;
            }
            if (taller)                              //插入到右子树中且长高了
            {
                switch ((*T)->bf)                       //T插入结点后，检测平衡因子，根据情况，做相应的修改和旋转
                {
                case LH:
                    (*T)->bf = EH;
                    taller = false;
                    break;
                case EH:
                    (*T)->bf = RH;
                    taller = true;
                    break;
                case RH:
                    RightBalance(T);                 //插入后右边不平衡了，让其右平衡
                    taller = false;
                    break;
                }
            }
        }
    }
    return true;
}

//先序遍历
void PreOrder(BitNode* BitNode){
    if(BitNode!=NULL){
        cout<<BitNode->data<<" ";
        PreOrder(BitNode->left);
        PreOrder(BitNode->right);
    }
}

void SqlPreOrder(BitTree T)//先序非递归遍历
  {
     stack<BitTree> s;
     BitTree p=T;
     while(p || !s.empty())
      {
          if(p)
          {
              cout<<p->data<<" ";
             s.push(p);
              p=p->left;
          }
         else
          {
              p=s.top();
              p=p->right;
             s.pop();
          }
    }
}

//中序遍历
void InOrder(BitNode* BitNode){  
    if(BitNode!=NULL){
        InOrder(BitNode->left);
        cout<<BitNode->data<<" ";
        InOrder(BitNode->right);
    }
}

void SqlInOrder(BitTree T)//中序非递归遍历
 {
     stack<BitTree> s;
     BitTree p=T;
      while(p || !s.empty())
          if(p)
         {
              s.push(p);
              p=p->left;
          }
          else
          {
              p=s.top();
              cout<<p->data<<" ";
              s.pop();
              p=p->right;
          }
  }

//后序遍历
void PostOrder(BitNode* BitNode){  
    if(BitNode!=NULL){
        PostOrder(BitNode->left);
        PostOrder(BitNode->right);
        cout<<BitNode->data<<" ";
    }
}

void SqlPostOrder(BitTree T)//后序非递归遍历1
  {
      stack<BitTree> s;
      BitTree p=T,r;
      while(p || !s.empty())
      {
          if(p)                             //走到最左边
          {
              s.push(p);
              p=p->left;
          }
          else                             //向右
          {
              p=s.top();//取栈顶结点
              if(p->right && p->right!=r)//如果右子树存在，且未被访问过
              {
                  p=p->right;
                  s.push(p);
                  p=p->left;             //再走到最左
              }
              else                         //否则，访问栈顶结点并弹出
              {
                  cout<<p->data<<" ";
                  r=p;                     //记录该结点
                 s.pop();
                 p=NULL;                     //结点访问完后，重置p指针
            }
         }
     }
 }

void FreeBitNode(BitNode* BitNode){
    if(BitNode==NULL){
        return;
    }
    if((BitNode->left==NULL)&&(BitNode->right==NULL)){
        free(BitNode);
        BitNode=NULL;
        return ;
    }
    if(BitNode->left!=NULL){
        FreeBitNode(BitNode->left);
    }
    if(BitNode->right!=NULL){
        FreeBitNode(BitNode->right);
    }
}

bool FindNode(BitNode* Tree,int val){
    if(Tree==NULL){
        return false;
    }
    if(Tree->data==val){
        return true;
    }else if(Tree->data>val){
        return FindNode(Tree->left,val);
    }else{
        return FindNode(Tree->right,val);
    }
}

//删除节点
bool DeleteNode(BitTree *T, int val,bool &taller) {
	if ((*T) == NULL) {
		return false;
	}
	else if (val == (*T)->data) {
		BitTree temp = NULL;
		if ((*T)->left == NULL) {
			temp = (*T);
			(*T) = (*T)->right;
			free(temp);
			taller = true;
		}
		else if ((*T)->right == NULL) {
			temp = (*T);
			(*T) = (*T)->left;
			free(temp);
			taller = true;
		}
		else {                                         
			temp = (*T)->left;                              
			while (temp->right) {
				temp = temp->right;
			}
			(*T)->data = temp->data;
			DeleteNode(&(*T)->left, temp->data, taller);
		}
	}
	else if (val < (*T)->data) {
		if (!DeleteNode(&(*T)->left, val, taller)) {
			return false;
		}
		if (taller) {
			switch ((*T)->bf)
			{
			case LH: 
				(*T)->bf = EH;
				taller = true;
				break;
			case RH:
				RightBalance(T);
				if ((*T)->right->bf == EH) {
					taller = false;
				}
				else {
					taller = true;
				}
				break;
			case EH:
				(*T)->bf = RH;
				taller = false;
				break;
			}
		}
	}
	else {
		if (!DeleteNode(&(*T)->right, val, taller)) {
			return false;
		}
		if (taller) {
			switch ((*T)->bf)
			{
			case LH:
				LeftBalance(T);
				if ((*T)->left->bf == EH) {
					taller = false;
				}
				else {
					taller = true;
				}
				break;
			case EH:
				(*T)->bf = LH;
				taller = false;
				break;
			case RH:
				(*T)->bf = EH;
				taller = true;
				break;
			}
		}
	}
	return true;
}

int main(){
    BitNode* BitNode=NULL;
    int a[9]={2,3,2,4,4,6,8,3,84};
    bool taller=true;
    for(int i=0;i<9;i++){
        //cout<<"null point"<<endl;
        InsertAVL(&BitNode,a[i],taller);
        taller=true;
    }
    
    if(BitNode!=NULL){
       //使用递归方法实现树的先序，中序，后序遍历
        cout<<"<--使用递归方法实现树的先序，中序，后序遍历-->"<<endl;
        PreOrder(BitNode);
        cout<<endl;
        InOrder(BitNode);
        cout<<endl;
        PostOrder(BitNode);
        cout<<endl<<endl;
        
        //使用栈实现树的先序，中序，后序遍历
        cout<<"<--使用栈实现树的先序，中序，后序遍历-->"<<endl;
        SqlPreOrder(BitNode);
        cout<<endl;
        SqlInOrder(BitNode);
        cout<<endl;
        SqlPostOrder(BitNode);
        cout<<endl<<endl;       
    }else{
        cout<<"null point"<<endl;
    }
    taller=false;
    if(FindNode(BitNode,2)){
        cout<<"OK,节点2存在"<<endl;
    }
    DeleteNode(&BitNode,2,taller); 
    if(!FindNode(BitNode,2)){
        cout<<"OK,节点2已经被删除"<<endl;
    }
    cout<<endl<<"-----检查2节点是否删除?"<<endl;
    PreOrder(BitNode);
    FreeBitNode(BitNode);
    system("pause");
    return 0;
}

输出结构

资料参考：https://blog.csdn.net/qq_29542611/article/details/80136574
https://blog.csdn.net/weixin_42154649/article/details/80831573

hzx5200693
关注
专栏目录
数据结构与算法 全 数据结构与算法全 Java
03-04
10) **根据中序与后序遍历结果构造二叉树**：根据中序和后序遍历结果重建二叉树。 #### 三、基础算法 **3.1 查找** - **概述**：查找算法用于在数据集中定位特定元素。 - **线性查找**：顺序检查数据集中的每一个...
数据结构与算法之平衡二叉树(AVL)的插入、旋转以及遍历
five-five
06-05 1144
平衡二叉树 (AVL,Balanced Binary Tree)，简称平衡树 (AVL 树)-- 树上任一结点的左子树和右子树的高度之差不超过 1。 平衡二叉树的插入 假定有如下子树，{A}、{B}、{AR}、{BL}、{BR}，且假定所有子树的高度为 H(或者你认为是 1 也可以)。如下图 即：A 的平衡粒子为 1，B 为 0，AR 无子树 现在：以 LL(左孩子的左子树) 插入，操作如下图： 此时：B 的子树高度为 H+1(已做 LL 操作)，AR 不变，那 A 的平衡因子为 2 了。此时就成 A
数据结构篇十二：平衡二叉树
Dzp199903的博客
03-25 2459
平衡二叉树 平衡二叉树就是对二叉查找树的优化升级，它要求每个节点的左右子树的高度相差不大于1 1.平衡二叉树的查找 平衡二叉树和二叉排序树的查找是一摸一样的。 2.平衡二叉树的顺序输出 平衡二叉树的中序遍历和二叉排序树一样，都是可以输出一个有序的数列。 3.平衡二叉树的插入 平衡二叉树在插入数据时，当发生了高度的不平衡时，会采取4种旋转操作：LL,RR,LR,RL（左左，右右，左右，右左）旋转，我们来一一分析这4种旋转方式。 RR调整 针对右孩子的右子树引起的不平衡 调整策略 右孩子c左上旋
数据结构与算法之平衡二叉树的构建和遍历
lin1214000999的博客
03-12 772
定义： 平衡二叉树（Balanced Binary Tree）具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。 产生原因： 如果待添加节点的值是有顺序的如{1，3，5，8，9，13}按照排序二叉树就会排列成如下图所示，这样它更像链表，添加效率高，遍历效率低，因为每次还...
最全二叉树：完整详解二叉树的遍历以及完全二叉树等6种二叉树
jjc4261的博客
03-09 1391
二叉树：就是每个节点都只能有两个子节点的树结构，俗称 “大裤衩”，特别形象。通常子树被称作“左子树”（left subtree）和“右子树下图你一看就秒懂了。通过上述的介绍，已经对于二叉树有了初步的认识。本篇文章介绍的基础知识希望读者能够牢牢掌握，并且能够在脑海中建立一棵二叉树的模型，为后续学习数据结构与算法打好基础。
详细图解,二叉排序树的遍历、删除、插入，通过bf优化构建成平衡二叉树(avl树)的原理
yadoufeng的专栏
05-28 1677
二叉排序树的插入，遍历，删除。插入时通过bf优化构建成平衡二叉树(avl树)的原理
数据结构 代码实现（很全）
10-17
2. **树形结构**：如二叉树、平衡树（AVL树、红黑树）、B树和B+树。二叉树每个节点最多有两个子节点，常用于搜索和排序；AVL树和红黑树是自平衡的，保证了搜索、插入和删除操作的高效性；B树和B+树是数据库和文件...
最全数据结构1800题与答案
05-13
- 平衡二叉树：如AVL树和红黑树，保证查找效率。 - 森林和二叉树的转换：学习如何在二叉树和森林间转换。 4. **图** - 图的表示：邻接矩阵和邻接表。 - 图的遍历：深度优先搜索（DFS）和广度优先搜索（BFS）。 ...
二叉树的建立.zip
12-04
首先，我们要理解二叉树的几种基本类型：满二叉树、完全二叉树和平衡二叉树。满二叉树是所有层都完全填充的树，除了可能的最后一层，且最后一层的所有节点都尽可能地靠左。完全二叉树与满二叉树类似，但最后一层的...
二叉树(1).docx
05-24
- **定义**：AVL树是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 - **性质**：AVL树通过旋转操作来保持树的平衡性，从而保证查找、插入和删除操作的时间复杂度均为 \...
平衡二叉树（AVL）的实现(详细) c++ 二叉排序树
Tree_sea的博客
07-31 3208
平衡二叉树概念 平衡二叉排序树（Balanced Binary Tree），因由前苏联数学家Adelson-Velskii 和 Landis于1962年首先提出的，所以又称为AVL树。 平衡二叉树是一种特殊的二叉排序树，理解平衡二叉树首先要理解什么是二叉排序树。 如果已经了解二叉排序树可以直接看下面平衡二叉树内容。 二叉排序树（Binary Sort Tree） 所谓二叉排序树(BST)即： （1）若该树的左子树不为空，那么左子树所以结点的值均小于其根结点的值。 （2）若该树的右子树不为空，那么右子树所
平衡二叉树实现
卧龙小蛋的博客
12-27 424
实现平衡二叉树平衡二叉树概念平衡二叉树实现原理具体代码实现 平衡二叉树概念 在保持二叉树的基本原则外，任意结点左右子树高度差绝对值不超过1。 平衡二叉树实现原理 平衡二叉树相较于二叉搜索树会增加一个高度标识，用来标识每个结点的高度height，既而更方便的算出是否符合结点左右子树高度差balance绝对值小于等于1。每当插入一个结点，先检查是否因插入而破坏了树的平衡性，若是，则找出最小不平衡子树，...
[数据结构] 平衡二叉树的实现
梦痕
02-13 1074
目录1. 二叉排序树2. 平衡因子3. 平衡二叉树4. 最小不平衡子树5. 平衡二叉树实现原理6 旋转  6.1 右旋（LL型）  6.2 左旋（RR型）  6.3 LR 型  6.4 RL型 1. 二叉排序树 对一个二叉树中序遍历能得到一个有序序列的二叉树即为二叉排序树 2. 平衡因子 二叉树上的节点左右子树的深度之差为平衡因子，记为BF（Blance Factor） 3. 平衡二叉树 一个二叉排序树中各节点的左右子树高度差不超过1，也即每个节点的平很因子BF为0、-1或1 4. 最小不平衡子
平衡搜索二叉树之AVL树解析
qq_68140277的博客
03-14 687
树这个神奇的结构，由于其带有数学中指数增长的性质，再给予其一些特殊的性质后，被广泛应用于存储和搜索等苦力活，今天我们来学习用来搜索二叉树中的AVL树是如何实现高效的搜索功能的。
二叉树之前序、中序、后序和层次遍历【图文教程】
IT_Most的博客
10-08 1584
二叉树之前序、中序、后序和层次遍历。看这一篇就够了~
二叉树顺序和链式结构及实现（图文版）
aaaaauaan的博客
06-19 2382
1.树的概念及结构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个特殊的结点，称为根结点，根节点没有前驱结点除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继因此，树是递归定义的 节点的度：一个节点含有的子树的个数称
讲解平衡二叉树的实现（C语言）
weixin_62756978的博客
04-06 1279
讲解如何实现平衡二叉树的构造、增加节点、删除节点等操作。
C语言代码实现平衡二叉树|图解+详细代码
最新发布
2401_82584055的博客
05-04 695
平衡二叉树，我们也称【二叉平衡搜索树/AVL】,树中任何节点的两个子树的高度最大差别为1，巴拉巴拉。。。https://baike.baidu.com/item/AVL树/10986648?fr=aladdin但是有个注意的点: 平衡二叉树的前提是 二叉排序树(https://baike.baidu.com/item/二叉搜索树/7077855?fr=aladdin这篇博客主要总结平衡二叉树，所以，二叉排序树知识不会提及，但是会用到。
平衡二叉树的四种遍历方式
Kim_
12-05 5773
一、概念       平衡二叉树或者是棵空树，或者是具体下列性质的二叉查找树：它的左子树和右子树都是平衡二叉树，且左子树和右子树的高度只差的绝对值不超过1。若将二叉树结点的平衡因子定义为该节点的左子树的高度减去它的右子树的高度，则所有结点的平衡因子只可能为-1,0,1。只要有一个结点的平衡因子的绝对值大于1，那么这棵树就失去了平衡。   简单例子 下图为平衡二叉树 下图为非平衡二叉树 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值