搜索算法测试-构建平衡二叉树

已于 2022-05-09 12:15:44 修改
阅读量848 收藏 1
点赞数
分类专栏： 算法 文章标签： 算法
于 2022-05-08 19:57:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18854309/article/details/124650068
版权
本文介绍了平衡二叉树的概念，包括其作为二叉排序树的特性及高度平衡的条件。详细阐述了四种旋转操作：LL型、RR型、LR型和RL型，用于在插入和删除节点时保持树的平衡。此外，提供了C语言实现的平衡二叉树插入节点的代码，并展示了插入一系列数值后的树结构和遍历操作。测试结果显示，插入操作会触发相应的旋转，以保持树的平衡，确保搜索效率为O(logn)。然而，频繁的插入和删除可能导致效率下降。
摘要由CSDN通过智能技术生成

1、平衡二叉树

        平衡二叉树(Self-Balancing Binary Search Tree 或 Height-Balanced Binary Search Tree)是树的一种特殊的结构。平衡二叉树的组成条件是必须是二叉排序树，且高度平衡。

  •   二叉排序树 

一棵空树，或者是具有下列性质的二叉树：

（1）若左子树不空，则左子树上所有节点的值均小于它的根节点的值；

（2）若右子树不空，则右子树上所有节点的值均大于它的根节点的值；

（3）左、右子树也分别为二叉排序树；

【注】：没有键值相等的节点。

  • 高度平衡

（1）一棵空树；

（2）或它的左子树和右子树都是平衡二叉树；

（3）且左子树和右子树的深度差的绝对值不超过1。

【注】：二叉树上节点的左子树深度减去右子树深度的值称为平衡因子BF(Balance Factor)。

2、平衡二叉树的操作

​ 当插入或删除元素时，会破坏二叉树的平衡。通过以下4种操作，可以恢复平衡：

LL型：插入左节点的左子树，右旋。

RR型：插入右节点的右子树，左旋。

 

LR型：插入左节点的右子树，先左旋，再右旋。

RL型：插入右节点的左子树，先右旋，再左旋。

 3、测试代码

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

typedef struct BinaryNode{
    int iValue;
    int iHeight;
    struct BinaryNode *pstLeft;
    struct BinaryNode *pstRight;
}BINARY_NODE_S;

int getNodeHeight(BINARY_NODE_S *pstNode)
{
    if(NULL == pstNode)
    {
        return 0;
    }
    else
    {
        return pstNode->iHeight;
    }
}

int getNodeMaxHeight(BINARY_NODE_S *pstNode)
{
    int iLeftHeight;
    int iRightHeight;

    iLeftHeight = getNodeHeight(pstNode->pstLeft);
    iRightHeight = getNodeHeight(pstNode->pstRight);

    return iLeftHeight > iRightHeight ? iLeftHeight : iRightHeight;
}

BINARY_NODE_S *rotateRight(BINARY_NODE_S *pstRoot)
{
    BINARY_NODE_S *pstNode;

    pstNode = pstRoot->pstLeft;
    pstRoot->pstLeft = pstNode->pstRight;
    pstNode->pstRight = pstRoot;

    pstRoot->iHeight = getNodeMaxHeight(pstRoot) + 1;
    pstNode->iHeight = getNodeMaxHeight(pstNode) + 1;

    return pstNode;
}

BINARY_NODE_S *rotateLeft(BINARY_NODE_S *pstRoot)
{
    BINARY_NODE_S *pstNode;

    pstNode = pstRoot->pstRight;
    pstRoot->pstRight = pstNode->pstLeft;
    pstNode->pstLeft = pstRoot;

    pstRoot->iHeight = getNodeMaxHeight(pstRoot) + 1;
    pstNode->iHeight = getNodeMaxHeight(pstNode) + 1;

    return pstNode;
}

BINARY_NODE_S *rotateLeftRight(BINARY_NODE_S *pstRoot)
{
    pstRoot->pstLeft = rotateLeft(pstRoot->pstLeft);
    return rotateRight(pstRoot);
}

BINARY_NODE_S *rotateRightLeft(BINARY_NODE_S *pstRoot)
{
    pstRoot->pstRight = rotateRight(pstRoot->pstRight);
    return rotateLeft(pstRoot);
}

BINARY_NODE_S *addNode(BINARY_NODE_S *pstRoot, int iValue)
{
    int iLeftHeight;
    int iRightHeight;

    if(NULL == pstRoot)
    {
        pstRoot = (BINARY_NODE_S *)malloc(sizeof(BINARY_NODE_S));
        pstRoot->iValue = iValue;
        pstRoot->iHeight = 1;
        pstRoot->pstLeft = NULL;
        pstRoot->pstRight = NULL;
    }
    else if(iValue < pstRoot->iValue)
    {
        pstRoot->pstLeft = addNode(pstRoot->pstLeft, iValue);
        pstRoot->iHeight = getNodeMaxHeight(pstRoot) + 1;

        iLeftHeight = getNodeHeight(pstRoot->pstLeft);
        iRightHeight = getNodeHeight(pstRoot->pstRight);

        if(2 == iLeftHeight - iRightHeight)
        {
            if(iValue < pstRoot->pstLeft->iValue)
            {
                printf("Left-Left: Right rotate.\n");
                pstRoot = rotateRight(pstRoot);
            }
            else
            {
                printf("Left-Righ: Left and right rotate.\n");
                pstRoot = rotateLeftRight(pstRoot);
            }
        }
        else
        {
            printf("Left add.\n");
        }
    }
    else
    {
        pstRoot->pstRight = addNode(pstRoot->pstRight, iValue);
        pstRoot->iHeight = getNodeMaxHeight(pstRoot) + 1;

        iLeftHeight = getNodeHeight(pstRoot->pstLeft);
        iRightHeight = getNodeHeight(pstRoot->pstRight);

        if(-2 == iLeftHeight - iRightHeight)
        {
            if(iValue > pstRoot->pstRight->iValue)
            {
                printf("Right-Right: Left rotate.\n");
                pstRoot = rotateLeft(pstRoot);
            }
            else
            {
                printf("Right-Left: Right and left rotate.\n");
                pstRoot = rotateRightLeft(pstRoot);
            }
        }
        else
        {
            printf("Right add.\n");
        }
    }

    return pstRoot;
}

/* 释放树：后序 */
void deInitTree(BINARY_NODE_S *pstRoot)
{
    if(NULL != pstRoot)
    {
        deInitTree(pstRoot->pstLeft);
        deInitTree(pstRoot->pstRight);
        free(pstRoot);
    }
}

/* 遍历树：前序 */
void scanTreePre(BINARY_NODE_S *pstRoot)
{
    if(NULL != pstRoot)
    {
        printf("%d ", pstRoot->iValue);
        scanTreePre(pstRoot->pstLeft);
        scanTreePre(pstRoot->pstRight);
    }
}

/* 遍历树：中序 */
void scanTreeIn(BINARY_NODE_S *pstRoot)
{
    if(NULL != pstRoot)
    {
        scanTreeIn(pstRoot->pstLeft);
        printf("%d ", pstRoot->iValue);
        scanTreeIn(pstRoot->pstRight);
    }
}

/* 遍历树：后序 */
void scanTreePost(BINARY_NODE_S *pstRoot)
{
    if(NULL != pstRoot)
    {
        scanTreePost(pstRoot->pstLeft);
        scanTreePost(pstRoot->pstRight);
        printf("%d ", pstRoot->iValue);
    }
}

/* 创建树 */
BINARY_NODE_S *InitTree(void)
{
    int auiDate[] ={3,2,1,4,5,6,7,10,9,8};
    BINARY_NODE_S *pstRoot = NULL;

    for(int i=0; i<sizeof(auiDate)/sizeof(auiDate[0]); ++i)
    {
        printf("\n====== Add: %d\n", auiDate[i]);
        pstRoot = addNode(pstRoot, auiDate[i]);

        printf("Tree: ");
        scanTreePre(pstRoot);
        printf("\n");
    }

    return pstRoot;
}

int main()
{
    BINARY_NODE_S *pstRoot;

    pstRoot = InitTree();

    printf("\nPre:  ");
    scanTreePre(pstRoot);
    printf("\n");

    printf("In:   ");
    scanTreeIn(pstRoot);
    printf("\n");

    printf("Post: ");
    scanTreePost(pstRoot);
    printf("\n");

    deInitTree(pstRoot);

    return 0;
}

 4、测试log

====== Add: 3
Tree: 3

====== Add: 2
Left add.
Tree: 3 2

====== Add: 1
Left add.
Left-Left: Right rotate.
Tree: 2 1 3

====== Add: 4
Right add.
Right add.
Tree: 2 1 3 4

====== Add: 5
Right add.
Right-Right: Left rotate.
Right add.
Tree: 2 1 4 3 5

====== Add: 6
Right add.
Right add.
Right-Right: Left rotate.
Tree: 4 2 1 3 5 6

====== Add: 7
Right add.
Right-Right: Left rotate.
Right add.
Tree: 4 2 1 3 6 5 7

====== Add: 10
Right add.
Right add.
Right add.
Tree: 4 2 1 3 6 5 7 10

====== Add: 9
Left add.
Right-Left: Right and left rotate.
Right add.
Right add.
Tree: 4 2 1 3 6 5 9 7 10

====== Add: 8
Right add.
Left add.
Right-Left: Right and left rotate.
Right add.
Tree: 4 2 1 3 7 6 5 9 8 10

Pre:  4 2 1 3 7 6 5 9 8 10
In:   1 2 3 4 5 6 7 8 9 10
Post: 1 3 2 5 6 8 10 9 7 4

​5、最终创建二叉树

6、算法分析

  • 搜索时间效率为O(log n)；
  • 频繁的插入和删除，会引起频繁的旋转，导致效率下降；
拥抱藍天
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
使用 TKYAVLTree 测试平衡二叉树类
06-22
/* TDemoTree - 测试平衡二叉树类 */ class TDemoTree { private: // 树结点 typedef struct { KYString* CallID; // 项数据 long ChanNo; // 自定义数据 } TNode, *PNode; public: TDemoTree(); virtual ~TDemoTree(); // 属性 long Count() const { return FCallIDs->Count(); } TKYLogObj* LogObj() const { return FLogObj; } // 方法 bool Find(const KYString& ACallID, long& AChanNo); bool Add(const KYString& ACallID, long AChanNo); void Delete(const KYString& ACallID); void Clear(); void OutputTree(); void WriteLog(const KYString& ALog) { FLogObj->WriteID(Time(), ALog); } protected: // 读锁 void LockRead() const { FLockRW->LockRead(); } void UnlockRead() const { FLockRW->UnlockRead(); } // 写锁 void LockWrite() const { FLockRW->LockWrite(); } void UnlockWrite() const { FLockRW->UnlockWrite(); } private: KYString NodeLink(const TNode* ANode); // FCallIDs 的事件方法 void DoCompare(const TNode* ANode1, const TNode* ANode2, long& ACompare); void DoDeletion(void* Sender, TNode* ANode); private: TKYLockRW* FLockRW; TKYLogObj* FLogObj; TKYAVLTree* FCallIDs; };
课设 - 平衡二叉树的演示 .docx
02-02
在数据结构课程设计中，构建一个平衡二叉树的演示系统是常见的任务，目的是让学生深入理解和应用这种数据结构。 **一、平衡二叉树的操作** 1. **创建**：创建一个非空的平衡二叉树通常从根节点开始，然后根据插入...
《程序员面试金典》--平衡二叉树的检测
zdplife的专栏
10-06 1275
题目描述:        实现一个函数，检查二叉树是否平衡，平衡的定义如下，对于树中的任意一个结点，其两颗子树的高度差不超过1。给定指向树根结点的指针TreeNode* root，请返回一个bool，代表这棵树是否平衡。 题目分析： ：       平衡二叉树是通过左右子树的高度来判断是否为平衡二叉树的，所以我们首先想到的是如何求一个树的高度，求一个树的高度很简单，递归求解，每次求出左右子
软测验点---平衡二叉树
weixin_33688840的博客
06-18 101
在平衡二叉树           (Balanced binarytree)是由阿德尔森-维尔斯和兰迪斯(Adelson-Velskii and Landis)于1962年首先提出的，所以又称为AVL树。           一、平衡二叉树的基本介绍           定义：平衡二叉树或为空树,或为例如以下性质的二叉排序树:         （1）左右子树深度之差的...
算法其实很简单—平衡二叉树的构建
我愿随风而行 的博客
06-02 2080
1. 基本概念 平衡二叉树的本质其实也是二叉排序树，具体可参考： 算法其实很简单—二叉排序树的构建 算法其实很简单—二叉排序树的删除 平衡二叉树的特点是任意节点的子树的高度差都小于等于1。 2. 整体思路 平衡二叉树的构建基本分为三种情况，左旋转、右旋转、双旋转 1、当根节点的右子树的高度比左子树高度大于1时，即高度相差2以上，则进行左旋转，思路如下图： 2、当根节点的左子树的高度比右子树高度大于1时，则进行右旋转： 3、如下图，复合右旋转条件，但是右旋转后还不是平衡二..
平衡二叉查找树的构建
weixin_51302779的博客
11-03 777
平衡二叉查找树的构建 笔者最近在数据结构的学习过程中，觉得有必要将重要的内容记录下来，供自己以后复习使用。以下内容若有错误之处还请指出。 1. 概念 二叉树中结点的平衡因子Balance Factor定义为该结点的左子树深度减去右子树深度，表示为 平衡二叉树可以是一棵空树，或者是满足以下性质的二叉树： abs(BF(A)) <= 1; 左子树和右子树都是一颗平衡二叉树，满足递归的定义。 平衡二叉查找树则是二叉查找树与平衡二叉树相结合，也简称为平衡二叉树。 2
数据结构课程设计-_平衡二叉树操作-副本.pdf
11-20
通过这个课程设计，学习者深入理解了如何构建和操作平衡二叉树，掌握了二分法构建树结构、平衡调整策略（旋转）以及在已知树结构中插入和删除结点的方法。 总结，平衡二叉树的设计与实现是一项关键的技能，它在...
C语言平衡二叉树.zip
10-28
本文将深入探讨C语言实现平衡二叉树的相关知识点，包括平衡二叉树的定义、类型、特性，以及如何在C语言中构建和操作这些数据结构。 平衡二叉树，顾名思义，是二叉树的一种特殊形式，它保持了树的高度平衡，从而确保...
平衡二叉树 java源码.zip
09-27
在Java中实现平衡二叉树，通常会用到AVL树或红黑树等算法。 AVL树是最早被提出的一种自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名AVL树。AVL树的关键特性是保持平衡因子为-1、0...
二叉树-基于Objective-C的完全二叉树实现的优先队列.zip
最新发布
04-26
这种数据结构广泛应用于各种算法和数据存储中，如搜索、排序、表达式求值等。Objective-C是苹果平台上的主要编程语言，它基于C语言并加入了面向对象的特性，使得构建复杂的数据结构如二叉树更为方便。 在这个项目中...
生成平衡二叉树
05-05
设二叉树节点值为大写字母，输入二叉树的前序遍历和中序遍历序列，生成此二叉树，输出该二叉树的后续遍历和按层次遍历序列。输入某节点值，在二叉树中查找该结点，若该结点存在，则输出从根到该结点的路径，否则给出不存在信息。
平衡二叉树的C算法实现
06-14
一个简单的平衡二叉树的C语言实现的代码一个简单的平衡二叉树的C语言实现的代码一个简单的平衡二叉树的C语言实现的代码一个简单的平衡二叉树的C语言实现的代码一个简单的平衡二叉树的C语言实现的代码一个简单的平衡二叉树的C语言实现的代码
搜索引擎PageRank算法实现及测试数据
06-09
搜索引擎PageRank算法实现及测试数据，测试输出，可执行文件。搜索引擎PageRank算法实现及测试数据，测试输出，可执行文件。
测试搜索算法研究
cloudday的专栏
11-01 864
所谓的排序结构研究法，不言而喻就是针对关键词检索结构的研究。通过搜索结果的分析可以寻找到，关键词布置的位置与频率。针对关键词采集搜索引擎排名的前十名的页面进行信息采集分析，统计出网页关键词密度、页面标签使用情况、和其他可能影响排名算法的因素，进而进行整理汇总，形成一套调整页面和网站结构的优化方法。 　　我们永远不知道搜索引擎内在的算法怎样，但是我们可以知道最终的结果是什么，通过对黑盒的测试，
数据结构——从0到1构建平衡二叉搜索树
qq_44003692的博客
11-21 535
文章目录前言平衡二叉搜索树 前言 此博客仅是本人复习时所记录 平衡二叉搜索树 平衡二叉搜索树（Balanced binary search tree），顾名思义，兼顾了 平衡二叉树 的性质与 二叉搜索树 的性质。 这里简单提及一下两种树形结构的性质。 二叉搜索树 它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树。 作为一种经典的数据结构，它既有
平衡二叉树测试分析
dydm_13128的专栏
03-20 807
额，本文主要是对平衡二叉树进行实现，以及测试节点的插入，删除，查找操作的效率分析。下面直接上代码： 头文件avltree.h: #ifndef _AVLTREE_H_ #define _AVLTREE_H_ #include using namespace std; //平衡与否标志 #ifndef LH //左子树高1 #define LH +1 #end
leetcode 108. Convert Sorted Array to Binary Search Tree 构建平衡二叉搜索树 + DFS深度优先遍历
JackZhangNJU的专栏
09-14 308
Given an array where elements are sorted in ascending order, convert it to a height balanced BST.根据一个排序好的数组构建一个平衡的二叉搜索树。 要和中后序构造BST、中前序构造BST一起学习。代码如下：/*class TreeNode { int val; TreeNode
搜索算法测试-散列（Hash）搜索
Sunny的博客
03-27 433
1、建立散列表 散列搜索 散列搜索不需要遍历很多次，他是尽量根据每个元素的特点（散列关系函数），构建散列表；然后搜索的时候只需要根据特点搜索，不需要遍历，这样比遍历查找效率要高很多，适用于大量数据，并且可用于字符串。 构建散列表 以关键字key为自变量，通过一个确定的函数 h（散列函数），计算出对应的函数值h(key)，作为数据对象的存储地址； 可能不同的关键字key会映射到同一个散列地址上，称为“冲突(Collision)”。 处理冲突的方法 开放地址法：冲突对象换个位置保存； 链地址法：
面试算法题：二叉树的平衡性检测
tyler_download的专栏
04-27 1144
二叉树由于其结构化清晰，并且变种多样，是面试中极为常见的考题。从本节开始，我们进入到有关二叉树面试题的研究中
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

拥抱藍天

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

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

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

打赏作者

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

抵扣说明：

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

余额充值