平衡二叉树的C++实现【C++模板类】

原创 已于 2024-11-06 10:22:09 修改 · 243 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #数据结构

于 2024-11-01 23:57:16 首次发布

平衡二叉树的C++实现

文章目录

介绍

平衡二叉树就是左右子树的高度差绝对值不超过1的二叉树，平衡二叉树解决了二叉排序树的最坏情况下退化为单链表的问题，即二叉排序树在最坏的情况下查找复杂度为O(n)，而平衡二叉树的查找时间复杂度为O(logn)。

一、C++模板类

代码如下：

#pragma once
#include <algorithm>

/*
 *brief  \二叉树的结构
 *param  \
 */
template<class Key, class Value>
struct AVLTreeNode
{
    Key key;
    Value value;
    int height = 1; // 节点高度为: 左孩子高度 - 右孩子高度
    AVLTreeNode<Key, Value>* leftChild = nullptr;
    AVLTreeNode<Key, Value>* rightChild = nullptr;

    AVLTreeNode() {}
    AVLTreeNode(Key k, Value v) : key(k), value(v) {}
};

/*
 *brief  \平衡二叉树
 *param  \
 */
template<class Key, class Value>
class AVLTree
{
public:
    AVLTree()
    {
    }

    ~AVLTree()
    {
        postOrder(m_root);
    }

    // 插入
    bool insert(const Key& key, const Value& value)
    {
        bool exist = false;
        m_root = recursiveInsert(m_root, key, value, exist);
        return !exist;
    }

    // 删除
    bool remove(const Key& key)
    {
        bool exist = false;
        m_root = deleteNode(m_root, key, exist);
        return exist;
    }

    // 查找
    bool search(const Key& key, Value& value)
    {
        bool exist = inOrder(m_root, key, value);
        return exist;
    }

    int height()
    {
        return height(m_root);
    }

private:
    // 找到node节点的中序后继
    AVLTreeNode<Key, Value>* inOrderNext(AVLTreeNode<Key, Value>* node)
    {
        AVLTreeNode<Key, Value>* child = node->rightChild;
        while (child->leftChild != nullptr)
            child = child->leftChild;
        return child;
    }

    // 中序遍历（查找）
    bool inOrder(AVLTreeNode<Key, Value>* node, const Key& key, Value& value)
    {
        if (node == nullptr)
            return false;

        if (node->key == key)
        {
            value = node->value;
            return true;
        }
        bool exist1 = inOrder(node->leftChild, key, value);
        bool exist2 = inOrder(node->rightChild, key, value);
        return exist1 || exist2;
    }

    // 后序遍历（删除）
    void postOrder(AVLTreeNode<Key, Value>* node)
    {
        if (node == nullptr)
            return;
        postOrder(node->leftChild);
        postOrder(node->rightChild);
        delete node;
    }

    int height(AVLTreeNode<Key, Value>* node)
    {
        return node ? node->height : 0;
    }

    // 是否平衡 |height(left) - height(right)| <= 1
    int isBalance(AVLTreeNode<Key, Value>* node)
    {
        return node ? height(node->leftChild) - height(node->rightChild) : 0;
    }

    // 左旋
    AVLTreeNode<Key, Value>* leftRotate(AVLTreeNode<Key, Value>* node)
    {
        /*
         * 在c的右侧插入元素 破坏平衡
                   a                    c
                    \                  / \
                     c        ->      a   ?
                      \
                       ?
        */

        AVLTreeNode<Key, Value>* right = node->rightChild;
        AVLTreeNode<Key, Value>* childLeft = right->leftChild;

        // c->left = a
        // a->right = c->left
        right->leftChild = node;
        node->rightChild = childLeft;

        // 旋转后的高度
        node->height = std::max(height(node->leftChild), height(node->rightChild)) + 1;
        right->height = std::max(height(right->leftChild), height(right->rightChild)) + 1;

        // 返回旋转后的父节点
        return right;
    }

    // 右旋
    AVLTreeNode<Key, Value>* rightRotate(AVLTreeNode<Key, Value>* node)
    {
        /*
         * 在b的左侧插入元素 破坏平衡
                   a                    b
                  /                    / \
                 b          ->        ?   a
                /
               ?
        */
        AVLTreeNode<Key, Value>* left = node->leftChild;
        AVLTreeNode<Key, Value>* childRight = left->rightChild;

        // b->right = a
        // a->left = b->right
        left->rightChild = node;
        node->leftChild = childRight;

        // 旋转后的高度
        node->height = std::max(height(node->leftChild), height(node->rightChild)) + 1;
        left->height = std::max(height(left->leftChild), height(left->rightChild)) + 1;

        // 返回旋转后的父节点
        return left;
    }

    // 插入
    AVLTreeNode<Key, Value>* recursiveInsert(AVLTreeNode<Key, Value>* node, const Key& key, const Value& value, bool& exist)
    {
        // 不存在 创建对象返回
        if (node == nullptr)
        {
            return new AVLTreeNode<Key, Value>(key, value);
        }

        // 已经存在 不处理
        if (key == node->key)
        {
            exist = true;
            return node;
        }

        if (key < node->key)
            node->leftChild = recursiveInsert(node->leftChild, key, value, exist);
        else if (key > node->key)
            node->rightChild = recursiveInsert(node->rightChild, key, value, exist);

        // 插入后node节点的高度 + 1
        node->height = std::max(height(node->leftChild), height(node->rightChild)) + 1;
        int balanceFactor = isBalance(node);

        // 往左孩子节点的左侧插入 LL：右旋
        if (balanceFactor > 1 && key < node->leftChild->key)
            return rightRotate(node);

        // 往右孩子节点的右侧插入 RR：左旋
        if (balanceFactor < -1 && key > node->rightChild->key)
            return leftRotate(node);

        // 往左孩子节点的右侧插入 LR：先左后右
        if (balanceFactor > 1 && key > node->leftChild->key)
        {
            node->leftChild = leftRotate(node->leftChild);  // 先调整node的左孩子
            return rightRotate(node);                       // 再调整node
        }

        // 往右孩子节点的左侧插入 RL：先右后左
        if (balanceFactor < -1 && key < node->rightChild->key)
        {
            node->rightChild = rightRotate(node->rightChild);  // 先调整node的右孩子
            return leftRotate(node);                           // 再调整node
        }
        return node;
    }

    // 递归删除
    AVLTreeNode<Key, Value>* deleteNode(AVLTreeNode<Key, Value>* root, const Key& key, bool& exist)
    {
        if (root == nullptr)
            return root;

        if (key < root->key)
        {
            // 往左孩子查找
            root->leftChild = deleteNode(root->leftChild, key, exist);
        }
        else if (key > root->key)
        {
            // 往右孩子查找
            root->rightChild = deleteNode(root->rightChild, key, exist);
        }
        else
        {
            exist = true;

            if (root->leftChild == nullptr)
            {
                // 父节点没有左孩子
                AVLTreeNode<Key, Value>* temp = root->rightChild;
                delete root;
                return temp;
            }
            else if (root->rightChild == nullptr)
            {
                // 父节点没有右孩子
                AVLTreeNode<Key, Value>* temp = root->leftChild;
                delete root;
                return temp;
            }

            // 如果存在左右孩子 找到节点的中序后继替换父节点 并删除中序后继节点
            AVLTreeNode<Key, Value>* next = inOrderNext(root);
            root->key = next->key;
            root->value = next->value;
            root->rightChild = deleteNode(root->rightChild, next->key, exist);
        }

        if (root == nullptr)
            return root;

        root->height = std::max(height(root->leftChild), height(root->rightChild)) + 1;
        int balanceFactor = isBalance(root);

        // LL: 父节点和左孩子节点都是左边高
        if (balanceFactor > 1 && isBalance(root->leftChild) >= 0)
            return rightRotate(root);

        // LR: 父节点左边高 左孩子节点右边高
        if (balanceFactor > 1 && isBalance(root->leftChild) < 0)
        {
            root->leftChild = leftRotate(root->leftChild);
            return rightRotate(root);
        }

        // RR: 父节点和右孩子节点都是右边高
        if (balanceFactor < -1 && isBalance(root->rightChild) <= 0)
            return leftRotate(root);

        // RL: 父节点右边高 右孩子节点左边高
        if (balanceFactor < -1 && isBalance(root->rightChild) > 0)
        {
            root->rightChild = rightRotate(root->rightChild);
            return leftRotate(root);
        }
        return root;
    }

private:
    AVLTreeNode<Key, Value>* m_root = nullptr;

};

二、使用方法

代码如下：

#include "AVLTree.h"

int main(int argc, char* argv[])
{
	AVLTree<std::string, std::string> avlTree;
	avlTree.insert("111", "记录美好");
	avlTree.insert("222", "记录生活");
	
	std::string value;
	if (avlTree.search("111", value))
	{
		// do something...
	}
	
	avlTree.remove("111");
	return 0;
}
Wu_miu
关注
二叉树(C++类模板实现)
zws的博客
11-21 4443
文章目录1. 二叉树的定义2.二叉树的性质3.二叉树的存储结构4. 代码 1. 二叉树的定义 后续更新 2.二叉树的性质 后续更新 3.二叉树的存储结构 顺序存储结构。顺序存储结构使用一组地址连续的存储单元来存储数据元素，为了能够在存储结构中反映出结点之间的逻辑关系，必须将二叉树中的结点依照一定的规律安排在这组单元中。 链式存储结构设计不同的结点结构可构成不同形式的链式存储结构。由二叉树的定义得知，二叉树的结点由一个数据元素和分别指向其左、 右子树的两个分支构成，则表示二叉树的链表 中的结点至少
平衡二叉树(AVL树)C++代码实现
RealCoder的博客
07-25 4080
目录平衡二叉树定义AVLAVLAVL树类的封装AVLAVLAVL树的插入操作与平衡化LLLLLL型调整RRRRRR型调整LRLRLR型调整RLRLRL型调整AVLAVLAVL树查找操作AVLAVLAVL树删除结点操作总源代码 平衡二叉树定义 为了使二叉排序树的平均查找长度更小，需要适当控制树高，显然，控制树高的一个有效措施就是尽量保持树的左右子树高度大致平衡，由此产生了平衡二叉树的概念。 G.M.Adelson−VelskiiG.M.Adelson-VelskiiG.M.Adelson−Velskii和E.
平衡二叉树c++实现
09-26
AVL的c++非递归实现 经测试可直接使用 由于在网上找的程序均有些小bug（可以用此程序中的测试代码测试，较少有别的代码能直接通过），所以自己写了一个。
数据结构之平衡二叉树（c++）
qq_57541265的博客
05-18 278
本文章主要介绍使用c++模板编写一个平衡二叉树，实现了平衡二叉树的 插入结点 平衡二叉树合并 删除结点 前序遍历 中序遍历 后续遍历 层次遍历 更新结点值 查找指定结点 清空结点 获取结点总数 获取叶子结点个数 获取非叶子结点个数 树的高度 树的深度 树是否为空
平衡二叉树（纯C++实现）
03-04
包含AVL树的创建，删除，查找等等功能，我使用的是VS2010的编译器，可能用版本低的编译器无法打开
C++笔记——平衡二叉树
永不秃头的三三的博客
02-08 1087
通过C++手撕一个平衡二叉树，实现插入、删除、查找、打印功能，以巩固自己的基础以及方便日后复习。
平衡二叉树插入、删除等操作的C++实现代码
06-15
用C++实现的二叉平衡树的插入、删除、中序遍历输出等操作
AVLTree自平衡二叉树C++模板类实现
01-19
使用C++实现的AVLTree自平衡二叉树，支持动态插入与删除操作，供C++数据结构课程学习与交流使用。
C++实现递归平衡二叉树模板类及其测试
3. C++模板类实现： - 使用C++模板类可以实现类型无关的平衡二叉树，可以适用于不同数据类型的存储。 - 树节点类通常包含数据域、左右子树指针、高度信息等。 - 树类中可能包含用于递归添加和删除节点的方法，...
东北·大学C++结课作业 模板平衡二叉树
02-08
在C++结课作业中，学生可能需要实现一个模板化的平衡二叉树类，包含基本操作如插入、删除和打印树形结构，以及平衡调整的相关功能。这将帮助他们理解和掌握C++的模板、二叉树和自平衡数据结构等核心概念。
平衡二叉树-AVL c/c++代码实现
xxxxxiao123的博客
07-02 344
一份代码，代码中有注释，对应着洛谷的**P3369 【模板】普通平衡树** /*Keep on going Never give up*/ #pragma GCC optimize(3,"Ofast","inline") #include <bits/stdc++.h> const int maxn = 2e5+10; const int MaxN = 0x3f3f3f3f; const int MinN = 0xc0c0c00c; typedef long long ll; const int
平衡二叉树（c++）
photoresist的博客
03-10 863
平衡二叉树定义平衡二叉树类二叉树的调整右单旋左单旋左右双旋插入删除操作完整代码 定义 平衡树(Balance Tree，BT) 指的是，任意节点的子树的高度差都小于等于1。常见的符合平衡树的有，B树（多路平衡搜索树）、AVL树（二叉平衡搜索树）等。平衡树可以完成集合的一系列操作, 时间复杂度和空间复杂度相对于“2-3树”要低，在完成集合的一系列操作中始终保持平衡，为大型数据库的组织、索引提供了一条新的途径 平衡二叉树类 继承二叉树类 二叉树类代码（GitHub）：https://github.com/r
平衡二叉树（C++）
Jerry_Leo_liu的博客
04-03 389
题目： 输入一棵二叉树，判断该二叉树是否是平衡二叉树。 思路： 当左右子树分别为平衡二叉树，且左右子树的深度差小于等于1时，该二叉树平衡 因此可以使用递归思想去判断子树的平衡性，再判断左右子树的深度差是否满足平衡条件 代码实现： class Solution { public: bool IsBalanced_Solution(TreeNode* pRoot) { ...
平衡二叉树的判断（哈哈哈哈自己写的，cool，先写一次的条件，不直接返回true再直接返回往下的）
weixin_44895315的博客
07-26 176
给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。 示例 1： 输入：root = [3,9,20,null,null,15,7] 输出：true 示例 2： 输入：root = [1,2,2,3,3,null,null,4,4] 输出：false 示例 3： 输入：root = [] 输出：true 提示： 树中的节点数在范围 [0, 5000] 内 -104 <= Node.val <= 1
平衡二叉树（C++实现）
weixin_42701161的博客
04-19 234
参考连接：https://blog.youkuaiyun.com/isunbin/article/details/81707606 #include<stdio.h> #include<stdlib.h> typedef struct Node { int key; struct Node *left; struct Node *right; int...
数据结构 - 平衡二叉树（C++）
热门推荐
了解➔熟悉➔掌握➔精通
02-22 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 平衡二叉树的定义 平衡二叉树（Balanced Binary Tree）是具有以下性质的二叉树：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 判断一棵二叉树是否平衡（C++） /* * Cr...
算法导论-AVL树的C++实现
爱冒险的技术宅
10-23 3541
代码主要来自网上流传的一份南京大学陈氏三姐妹的大作业。 花了一些时间测试和修改，代码基本OK了，结构也比较清晰。 我两把刷子，裸写的话没一个礼拜真下不来。 #include #include #include #define EQ(a,b) ((a)==(b)) #define LT(a,b) ((a)<(b)) #define LQ(a,b) ((a)>(b)) #define LH
C++实现平衡二叉树
最新发布
cctv1324的博客
04-14 1484
C++实现平衡二叉（排序）树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值