自己动手写二叉平衡树

最新推荐文章于 2024-08-16 10:13:06 发布
最新推荐文章于 2024-08-16 10:13:06 发布
阅读量320 收藏 1
点赞数
文章标签： tree null struct 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cs8900/article/details/5888644
版权
这篇博客详细介绍了如何自己动手编写二叉平衡树的代码，包括中序遍历、平衡因子测试、插入节点等功能，并提供了测试用例。通过示例展示了平衡树在插入操作后的调整过程。
摘要由CSDN通过智能技术生成

//还有不足或错误的地方，欢迎指正，仅供参考

 

#include <stdio.h>
#include <stdlib.h>

 

int num=2;
int tmpt=1;

 

typedef struct tree
{
    int data;
    int BF;     //平衡因子
    struct tree *left;
    struct tree *right;
    struct tree *parent;
}Tree;

 

void intree(Tree *t);
Tree * testbf(Tree *t);
int testcheng(Tree *t);
int changebf(Tree *t);
int insertnode(Tree *t,int dnode);

Tree *root=NULL;

 

void intree(Tree *t)  //中序遍历
{
    if(t == NULL)
        return ;
    intree(t->left);
    printf("%d bf=%d ",t->data,t->BF);
    intree(t->right);
    return ;
}

 

Tree * testbf(Tree *t)    //测试bf是否符合要求
{
    if(t->BF==-1 || t->BF==0 || t->BF==1)
        return t;
    else if(t->BF==2)
    {
        if(t->left->BF==1)
        {
            Tree *tmp=t->left;
            t->left=tmp->right;
            if(tmp->right!=NULL)
            {
                tmp->right->parent=t;
                t->left=tmp->right;
            }
            else
                t->left=NULL;
            tmp->right=t;
            if(t->parent!=NULL && t->parent->left->data==t->data)
            {
                tmp->parent=t->parent;
                t->parent->left=tmp;
                t->parent=tmp;
                t->BF=changebf(t);
                tmp->BF=changebf(tmp);
                return tmp;
            }
            else if(t->parent!=NULL && t->parent->right->data==t->data)
            {
                tmp->parent=t->parent;
                t->parent->right=tmp;
                t->parent=tmp;
                t->BF=changebf(t);
                tmp->BF=changebf(tmp);
                return tmp;
            }
            else if(t->parent==NULL)
            {
                tmp->parent=NULL;
                t->parent=tmp;
                t->BF=changebf(t);
                tmp->BF=changebf(tmp);
                root=tmp;  //因为遍历要从root开始，故这里要改变root的值
                return tmp;
            }

        }
        if(t->left->BF==-1)
        {
            Tree *tmpb=t->left;
            Tree *tmpc=tmpb->right;
            if(tmpc->left!=NULL)
            {
                tmpc->left->parent=tmpb;
                tmpb->right=tmpc->left;
            }
            else
                tmpb->right=NULL;
            if(tmpc->right!=NULL)
            {
                tmpc->right->parent=t;
                t->left=tmpc->right;
            }
            else
                t->left=NULL;
            tmpb->parent=tmpc;
            tmpc->left=tmpb;
            tmpc->right=t;
            if(t->parent!=NULL && t->parent->left->data==t->data)
            {
                tmpc->parent=t->parent;
                t->parent->left=tmpc;
                t->parent=tmpc;
                t->BF=changebf(t);
                tmpb->BF=changebf(tmpb);
                tmpc->BF=changebf(tmpc);
                return tmpc;
            }
            else if(t->parent!=NULL && t->parent->right->data==t->data)
            {
                tmpc->parent=t->parent;
                t->parent->right=tmpc;
                t->parent=tmpc;
                t->BF=changebf(t);
                tmpb->BF=changebf(tmpb);
                tmpc->BF=changebf(tmpc);
                return tmpc;
            }
            else if(t->parent==NULL)
            {
                tmpc->parent=NULL;
                t->parent=tmpc;
                t->BF=changebf(t);
                tmpb->BF=changebf(tmpb);
                tmpc->BF=changebf(tmpc);
                root=tmpc;
                return tmpc;
            }

        }
    }
    else if(t->BF==-2)
    {
        if(t->right->BF==-1)
        {
            Tree *tmpb=t->right;
            if(tmpb->left!=NULL)
            {
                tmpb->left->parent=t;
                t->right=tmpb->left;
            }
            else
                t->right=NULL;
            tmpb->left=t;
            if(t->parent!=NULL && t->parent->left->data==t->data)
            {
                tmpb->parent=t->parent;
                t->parent->left=tmpb;
                t->parent=tmpb;
                t->BF=changebf(t);
                tmpb->BF=changebf(tmpb);
                return tmpb;
            }
            else if(t->parent!=NULL && t->parent->right->data==t->data)
            {
                tmpb->parent=t->parent;
                t->parent->right=tmpb;
                t->parent=tmpb;
                t->BF=changebf(t);
                tmpb->BF=changebf(tmpb);
                return tmpb;
            }
            else if(t->parent==NULL)
            {
                tmpb->parent=NULL;
                t->parent=tmpb;
                t->BF=changebf(t);
                tmpb->BF=changebf(tmpb);
                root=tmpb;
                return tmpb;
            }
        }
        else if(t->right->BF==1 )
        {
            Tree *tmpb=t->right;
            Tree *tmpc=tmpb->left;
            if(tmpc->left!=NULL)
            {
                tmpc->left->parent=t;
                t->right=tmpc->left;
            }
            else
                t->right=NULL;
            if(tmpc->right!=NULL)
            {
                tmpc->right->parent=tmpb;
                tmpb->left=tmpc->right;
            }
            else
                tmpb->left=NULL;
            tmpc->left=t;
            tmpc->right=tmpb;
            tmpb->parent=tmpc;
            if(t->parent!=NULL && t->parent->left->data==t->data)
            {
                tmpc->parent=t->parent;
                t->parent->left=tmpc;
                t->parent=tmpc;
                t->BF=changebf(t);
                tmpb->BF=changebf(tmpb);
                tmpc->BF=changebf(tmpc);
                return tmpc;
            }
            else if(t->parent!=NULL && t->parent->right->data==t->data)
            {
                tmpc->parent=t->parent;
                t->parent->right=tmpc;
                t->parent=tmpc;
                t->BF=changebf(t);
                tmpb->BF=changebf(tmpb);
                tmpc->BF=changebf(tmpc);
                return tmpc;
            }
            else if(t->parent==NULL)
            {
                tmpc->parent=NULL;
                t->parent=tmpc;
                t->BF=changebf(t);
                tmpb->BF=changebf(tmpb);
                tmpc->BF=changebf(tmpc);
                root=tmpc;
                return tmpc;
            }
        }
    }
    else
        return;

}

 

int testcheng(Tree *t)   //返回以t为根的树的最大层数
{
    if(t->left==NULL && t->right==NULL)
    {
        num--;
        return;
    }
    if(t->left!=NULL)
    {
        if(num>tmpt)
            tmpt=num;
        num++;
        testcheng(t->left);

    }
    if(t->right!=NULL)
    {
        if(num>tmpt)
            tmpt=num;
        num++;
        testcheng(t->right);
    }
    num--;
    return tmpt;
}

 

int  changebf(Tree *t)  //修改bf
{
    Tree *tmp=NULL;
    int leftbf=0;
    int rightbf=0;
    if(t->left==NULL)
        leftbf=0;
    else
    {
        leftbf=testcheng(t->left);
        num=2;
        tmpt=1;
    }
    if(t->right==NULL)
        rightbf=0;
    else
    {
        rightbf=testcheng(t->right);
        num=2;
        tmpt=1;
    }
    t->BF=leftbf-rightbf;
    tmp=testbf(t);
    if(tmp->parent!=NULL)
    {
        changebf(tmp->parent);
        tmp=NULL;
    }
    tmp=NULL;
    return (t->BF);
}

 

int insertnode(Tree *t,int dnode)//插入节点
{
    if(t != NULL)
    {
        if(dnode < t->data)
        {
            if(t->left != NULL)
            {
                insertnode(t->left,dnode);
            }
            else
            {
                Tree *newnode=(Tree *)malloc(sizeof(Tree));
                newnode->data=dnode;
                newnode->BF=0;
                newnode->left=NULL;
                newnode->right=NULL;
                newnode->parent=t;
                t->left=newnode;
                changebf(newnode->parent);
                return ;
            }
        }
        else
        {
            if(t->right !=NULL)
            {
                insertnode(t->right,dnode);
            }
            else
            {
                Tree *newnode=(Tree *)malloc(sizeof(Tree));
                newnode->data=dnode;
                newnode->BF=0;
                newnode->left=NULL;
                newnode->right=NULL;
                newnode->parent=t;
                t->right=newnode;
                changebf(newnode->parent);
                return ;
            }
        }
    }
}

 


int main(int argc, char** argv)  //测试数据
{
    Tree *first=(Tree *)malloc(sizeof(Tree));
    first->data=5;
    first->BF=0;
    first->left=first->parent=first->right=NULL;
    root=first;
    intree(root);  printf("/n");
    insertnode(root,8);   intree(root);  printf("/n");
    insertnode(root,4);   intree(root);  printf("/n");
    insertnode(root,3);   intree(root);  printf("/n");
    insertnode(root,1);   intree(root);  printf("/n");
    insertnode(root,6);   intree(root);  printf("/n");
    insertnode(root,9);   intree(root);  printf("/n");
    insertnode(root,0);   intree(root);  printf("/n");
    insertnode(root,2);   intree(root);  printf("/n");
    return 0;
}

 // 测试结果


 
int main(int argc, char** argv)  //书本例子数据
{
    Tree *first=(Tree *)malloc(sizeof(Tree));
    first->data=13;
    first->BF=0;
    first->left=first->parent=first->right=NULL;
    root=first;
    intree(root);
    printf("/n");
    insertnode(root,24);
    intree(root);
    printf("/n");
    insertnode(root,37);
    intree(root);
    printf("/n");
    insertnode(root,90);
    intree(root);
    printf("/n");
    insertnode(root,53);
    intree(root);
    printf("/n");
    return 0;
}

 

//测试结果：

 

cs8900
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
图解平衡二叉树(AVL树)
Gebo的博客
03-23 1110
二叉搜索树（BST）存在的问题 我们先把{1,2,3,4,5,6}这颗二叉搜索树创建出来，结果如下图： 可以看出这颗而擦搜索树的左子树全部为空，看起来更像一个单链表. 此时它的插入速度没有影响，但查询速度明显降低(因为需要依次比较，所以时间复杂度变为O（n）), 不能发挥BST的优势，而且因为每次还需要比较左子树，其查询速度比单链表还慢。 为了解决以上问题于是主角登场了------平衡二叉树(A...
判断二叉平衡树的三种方法
指尖飞舞
08-10 3182
题目 实现一个函数，检查二叉树是否平衡。在这个问题中，平衡树的定义如下，任意一个节点，其两颗子树的高度差不超过1。 分析 判断平衡二叉树是一个常见题目，一般来说，我们都是求出左右子树的高度，根据定义判断其差。下面给出三种实现方法，大家可以对比其优劣。 代码 /* 题目描述 实现一个函数，检查二叉树是否平衡，平衡的定义如下，对于树中的任意一个结点， 其两颗子树的高度差不超过1。 给定指向
数据结构之二叉平衡树
随芯的博客
05-22 542
数据结构之 二叉平衡树 原则： 红黑树确保没有一条路径会比其他路径长出2倍 问题： 1.红黑树怎么保证平衡的，左右旋 目的是为达到平衡 2.左右旋是什么时间触发的，怎么工作的 解决问题： 思路 了解 左右旋是怎么工作的 右旋 /** * 右旋（左子树比右子树高2，并且新插入的元素在左子树的左边） ...
【数据结构】----平衡二叉树怎么自己画？
何新生(Daniel) 勇敢坚毅真正之才智乃刚毅之志向。 —— 拿破仑
01-08 3万+
【数据结构】平衡二叉树怎么自己画？        是什么？     要了解平衡二叉树，先得了解什么是二叉树？ 二叉树定义： 在计算机中，二叉树是每一个节点最多有两个子树的结构。通常子树被称作“左子树（left subtree）”“右子树（right subtree）”. 二叉树常被用于实现二叉树查找和二叉堆。 什么是平衡二叉树：      平衡二叉树（Balan
二叉平衡树的旋转操作
saasanken的博客
06-25 2万+
旋转是很多二叉平衡树维持平衡的主要手段，在这里复习一下。其实旋转过程中节点位置的变化只要遵循一个原则就行了：比Root小的在左子树，比Root大的在右子树。（当然这里前提条件是左小右大）。 情况一：插入F节点导致失衡： 这里失衡的是A的左右子树，很容易就可以想到旋转B-A链，值得注意的是E节点，它原先在B的右子树，现在也依然在B的右子树，它原先在A的左子树，现在也依然在A的左子树。 若插...
动手写一个二叉平衡树
jinjin603的博客
11-30 312
前面已经实现了一个二叉搜索树 比较复杂的就是在删除的时候，需要做比较多的判断，总体没那么难理解。 在二叉树的基础上，有一个叫做二叉平衡树的数据结构，实现起来难度还是比较大的。具体代码可参考：AVLTree ...
二叉查找树与平衡二叉树
热门推荐
金发只是水一下的博客
08-29 8万+
二叉查找树 　　二叉查找树，也称二叉搜索树，或二叉排序树。其定义也比较简单，要么是一颗空树，要么就是具有如下性质的二叉树： （1）若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2） 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3） 任意节点的左、右子树也分别为二叉查找树； （4） 没有键值相等的节点。 　　如上图所示，是不同形态...
bst.zip_bst_二叉查找树
09-23
5. **平衡操作 (平衡二叉查找树)**: 为了优化查找性能，有些二叉查找树会采用自平衡策略，如AVL树和红黑树。这些树在插入和删除后会自动调整结构以保持平衡，确保最坏情况下的搜索时间复杂度为O(log n)。 以上是...
数据结构实验之二叉排序树
06-03
总结来说，"数据结构实验之二叉排序树"是一个实践性的学习项目，旨在通过动手实现二叉排序树的查找、插入和删除操作，来巩固和加深对数据结构理论知识的理解。在这个过程中，学生将学习到如何使用MFC来构建交互式...
C++ 二叉排序树及查找哈夫曼树与哈夫曼编码 括号匹配检验
11-11
首先，二叉排序树是一种自平衡的二叉搜索树，其每个节点的值都大于左子树中所有节点的值，小于右子树中所有节点的值。这种特性使得二叉排序树在插入、删除和查找操作上具有较高的效率。在C++中，可以定义一个结构体...
数据结构二叉排序树课程设计报告报告.doc
10-03
这样的结构使得二叉排序树在查找、插入和删除操作上有较高的效率，尤其是在平衡的情况下。 ### 二、原理分析及流程 二叉排序树的操作主要包括以下四部分： 1. **创建二叉排序树**：从空树开始，逐步插入元素，...
C语言平衡二叉树.zip
10-27
Landis在1962年提出的，是最早出现的自平衡二叉搜索树。它的特点是任意节点的两个子树的高度差不超过1，从而保证了查找效率。 在C语言中实现平衡二叉树，我们需要定义一个结构体来表示树节点，通常包括键值（key）...
数据结构 平衡二叉排序树
cheneagle的专栏
08-06 7120
    平衡二叉树( AVL树 )：二叉排序树的查找与树的形态密切相关，当树的形态比较均衡时查找效率最高，当树的形态偏向于某一个方向是效率迅速降低，而一颗二叉树的形态取决于数据插入的先后顺序，如果构造一颗较均衡的二叉树比较困难。那有没有合适的方法把一颗不平衡的树调整为平衡的二叉树，答案是肯定的。这就是平衡二叉树在1962年由Adelson-Velskii和Landis提出的，所以又叫AVL树。
软件测试经典面试题（答案解析+文档）
HUA6911的博客
08-13 807
这些资料，对于做【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴我走过了最艰难的路程，希望也能帮助到你！凡事要趁早，特别是技术行业，一定要提升技术功底。
AI赋能软件测试：从自动化到智能化，让测试工作事半功倍
m0_64146991的博客
08-15 171
APP端测试，专项测试，测试工具
Java学习日记（day20）
qq_59031302的博客
08-14 378
MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。最简单的、最经典就是JSP(view) +Servlet(controller) + JavaBean(model)JavaBean：一种规范，表达实体和信息的规范，便于封装重用。什么是JavaBean。
软件测试.
qq_51240148的博客
08-12 282
..
Python 如何使用 mock 进行测试
最新发布
Itmastergo的博客
08-16 664
Mock 是一种模拟对象的技术，用于测试中替代真实的对象。通过 Mock 对象，我们可以在测试时完全控制被测代码的外部依赖，而不需要真正的依赖。隔离测试：通过使用 Mock 对象，可以避免测试中真实依赖的干扰，确保测试的稳定性和重复性。提高测试速度：Mock 可以替代一些耗时操作，如数据库查询或 API 调用，从而大幅度提高测试速度。更好的错误模拟：可以通过 Mock 对象来模拟一些异常情况或错误状态，从而测试代码的健壮性和容错性。
"数据结构与算法设计课程二叉排序树与平衡二叉树论文
本课程设计主要是针对数据结构与算法设计中的二叉排序树与平衡二叉树进行研究和实践。通过本次课程设计，旨在培养学生对于二叉排序树和平衡二叉树的理论知识的掌握能力，以及对于相关算法的分析和应用能力的培养。本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值