简单AVL树

最新推荐文章于 2024-06-13 23:56:26 发布
最新推荐文章于 2024-06-13 23:56:26 发布
阅读量35 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cai_hh/article/details/131436680
版权

自己写的简单AVL树实现,有BUG或意见欢迎留言

#ifndef SIMPLEAVLTREE_H
#define SIMPLEAVLTREE_H
#include "simplequeue.h"
#include "simplestring.h"
/*关键定义   左右子树高度差绝对值必须小于2
*/
template <typename T>
struct SimpleAvlTreeNode{
    T data;
    int depth;
    SimpleAvlTreeNode *parent;
    SimpleAvlTreeNode *lNode;
    SimpleAvlTreeNode *rNode;
    SimpleAvlTreeNode<T>(T data, int depth, SimpleAvlTreeNode* parent, SimpleAvlTreeNode* lNode, SimpleAvlTreeNode* rNode) :data(data), depth(depth), parent(parent), lNode(lNode), rNode(rNode) {}
};
template <typename T>
class SimpleAvlTree{
protected:
    SimpleAvlTreeNode<T> *root = nullptr;
public:
    //检查深度限制
    bool checkDepthLimit(SimpleAvlTreeNode<T>* currentNode);
    //左旋函数  目的:提升右子节点
    SimpleAvlTreeNode<T>* lRotate(SimpleAvlTreeNode<T> *currentNode);
    //右旋函数  目的:提升左子节点
    SimpleAvlTreeNode<T>* rRotate(SimpleAvlTreeNode<T> *currentNode);
    //更新深度信息
    SimpleAvlTreeNode<T>* updateDepth(SimpleAvlTreeNode<T> *currentNode);
    //增加节点
    void addNode(T data);
    //删除节点
    void removeNode(T data);
    void removeNode(SimpleAvlTreeNode<T>* currentNode);
    //获取根节点
    SimpleAvlTreeNode<T> *getRoot(){ return root; }
    //清除内存占用
    void clear(SimpleAvlTreeNode<T> *n);
    //获取特定节点
    SimpleAvlTreeNode<T>* getNode(T data);
    SimpleAvlTree(){}
    ~SimpleAvlTree(){ clear(root); }
};
//清空占用的空间
template <typename T>
void SimpleAvlTree<T>::clear(SimpleAvlTreeNode<T> *n){
    if(n->lNode != nullptr)clear(n->lNode);
    if(n->rNode != nullptr)clear(n->rNode);
    delete n;
}
//检查深度限制
template <typename T>
bool SimpleAvlTree<T>::checkDepthLimit(SimpleAvlTreeNode<T>* currentNode) {
    int lNodeDepth = currentNode->lNode == nullptr ? 0 : currentNode->lNode->depth;
    int rNodeDepth = currentNode->rNode == nullptr ? 0 : currentNode->rNode->depth;
    int depthOffset = lNodeDepth - rNodeDepth;
    if (depthOffset > 1 || depthOffset < -1)return false;
    else {
        //递归检查子节点
        bool result = true;
        if (currentNode->lNode != nullptr) {
            //检查大小限制
            if (currentNode->lNode->data >= currentNode->data)return false;
            result = checkDepthLimit(currentNode->lNode);
        }
        if (result) {
            if (currentNode->rNode != nullptr) {
                //检查大小限制
                if (currentNode->rNode->data <= currentNode->data)return false;
                result = checkDepthLimit(currentNode->rNode);
            }
            return result;
        }else return false;
    }
}
//右旋函数  目的:提升左子节点
//旋转过后  旋转点的原左节点的左节点深度不变,旋转点的新左节点深度不变,旋转点的深度需要改变,并继续更新
template <typename T>
SimpleAvlTreeNode<T>* SimpleAvlTree<T>::rRotate(SimpleAvlTreeNode<T> *currentNode){
    //std::cout << "右旋" << std::endl;
    //保留旋转点的左节点
    SimpleAvlTreeNode<T> *lNode = currentNode->lNode;
    //当旋转点的左节点的左节点非空,提升左子节点    还要求左节点的右节点为空或者其两个子节点均为空
    if (lNode->lNode != nullptr) {
        if (lNode->rNode == nullptr || (lNode->rNode->lNode == nullptr && lNode->rNode->rNode == nullptr)) {
            //将旋转点的左节点的右节点转为旋转点的左节点
            currentNode->lNode = lNode->rNode;
            if (lNode->rNode != nullptr)lNode->rNode->parent = currentNode;
            //将旋转点的左节点提升到旋转点所在位置
            lNode->parent = currentNode->parent;
            if (currentNode->parent != nullptr) {
                if (currentNode->parent->lNode == currentNode)currentNode->parent->lNode = lNode;
                else currentNode->parent->rNode = lNode;
                //父节点为空说明为root节点
            }
            else this->root = lNode;
            //旋转点成为旋转点的左节点的新右节点
            lNode->rNode = currentNode;
            currentNode->parent = lNode;
            return updateDepth(currentNode);
        }//当旋转点的左节点的左节点非空,且左节点的右节点存在子节点
        //推断   该左节点的右节点只有一个子节点,原因,只要插入一个节点就会导致重平衡  使用该节点替代旋转节点
        else {
            SimpleAvlTreeNode<T>* assistNode = nullptr;
            //当该左节点的右节点的左节点不为空 该左节点的右节点的左节点替代旋转节点
            if (lNode->rNode->lNode != nullptr) {
                assistNode = lNode->rNode->lNode;
                lNode->rNode->lNode = nullptr;
                //该左节点的右节点成为旋转节点的左子节点
                lNode->rNode->parent = currentNode;
                currentNode->lNode = lNode->rNode;
                lNode->rNode = nullptr;
            }//当该左节点的右节点的右节点不为空  该左节点的右节点替代旋转节点
            else {
                assistNode = lNode->rNode;
                lNode->rNode = nullptr;
                //该左节点的右节点的右节点成为旋转节点的左子节点
                assistNode->rNode->parent = currentNode;//因为后面重新赋值了assistNode->rNode,所以不需要置空
                currentNode->lNode = assistNode->rNode;
            }
            //使用该节点替代旋转节点
            assistNode->parent = currentNode->parent;
            if (currentNode->parent != nullptr) {
                if (currentNode->parent->lNode == currentNode)currentNode->parent->lNode = assistNode;
                else currentNode->parent->rNode = assistNode;
            }
            else this->root = assistNode;
            //该左节点和旋转节点分别成为该节点左右节点
            lNode->parent = assistNode;
            assistNode->lNode = lNode;
            currentNode->parent = assistNode;
            assistNode->rNode = currentNode;
            updateDepth(currentNode->lNode);
            updateDepth(currentNode);
            updateDepth(lNode);
            return updateDepth(assistNode);
        }
    }//当旋转点的左节点的左节点为空,提升左子节点的右子节点(此时左子节点的右子节点必不为空)
    else {
        SimpleAvlTreeNode<T>* assistNode = lNode->rNode;
        //左子节点的右子节点提升到旋转点所在位置
        assistNode->parent = currentNode->parent;
        if (currentNode->parent != nullptr) {
            if (currentNode->parent->lNode == currentNode)currentNode->parent->lNode = assistNode;
            else currentNode->parent->rNode = assistNode;
            //父节点为空说明为root节点
        }
        else this->root = assistNode;
        //断开左子节点的右子节点和左子节点的连接  左子节点的右子节点的左子节点成为左子节点的新右子节点，左子节点的右子节点的右子节点成为旋转点的新左子节点
        lNode->rNode = assistNode->lNode;
        if (lNode->rNode != nullptr)lNode->rNode->parent = lNode;
        currentNode->lNode = assistNode->rNode;
        if (currentNode->lNode != nullptr)currentNode->lNode->parent = currentNode;
        //左子节点成为左子节点的右子节点的新左子节点
        assistNode->lNode = lNode;
        lNode->parent = assistNode;
        //旋转点成为左子节点的右子节点的新右子节点
        assistNode->rNode = currentNode;
        currentNode->parent = assistNode;
        updateDepth(currentNode);
        updateDepth(lNode);
        return updateDepth(assistNode);
    }
}
//左旋函数  目的:提升右子节点
//旋转过后  旋转点的原右节点的右节点深度不变,旋转点的新右节点深度不变,旋转点的深度需要改变,并继续更新
template <typename T>
SimpleAvlTreeNode<T>* SimpleAvlTree<T>::lRotate(SimpleAvlTreeNode<T> *currentNode){
    //std::cout << "左旋" << std::endl;
    //保留旋转点的右节点
    SimpleAvlTreeNode<T> *rNode = currentNode->rNode;
    //当旋转点的右节点的右节点非空,提升右子节点    还要求右节点的左节点为空或者其两个子节点均为空
    if (rNode->rNode != nullptr) {
        if (rNode->lNode == nullptr || (rNode->lNode->lNode == nullptr && rNode->lNode->rNode == nullptr)) {
            //将旋转点的右节点的左节点转为旋转点的右节点
            currentNode->rNode = rNode->lNode;
            if (rNode->lNode != nullptr)rNode->lNode->parent = currentNode;
            //将旋转点的右节点提升到旋转点所在位置
            rNode->parent = currentNode->parent;
            if (currentNode->parent != nullptr) {
                if (currentNode->parent->lNode == currentNode)currentNode->parent->lNode = rNode;
                else currentNode->parent->rNode = rNode;
                //父节点为空说明为root节点
            }
            else this->root = rNode;
            //旋转点成为旋转点的右节点的新左节点
            rNode->lNode = currentNode;
            currentNode->parent = rNode;
            return updateDepth(currentNode);
        }//当旋转点的右节点的右节点非空,且右节点的左节点存在子节点
        //推断   该右节点的左节点只有一个子节点,原因,只要插入一个节点就会导致重平衡 使用该节点替代旋转节点
        else {
            SimpleAvlTreeNode<T>* assistNode = nullptr;
            //当该右节点的左节点的左节点不为空 
            if (rNode->lNode->lNode != nullptr) {
                //该右节点的左节点替代旋转节点
                assistNode = rNode->lNode;
                rNode->lNode = nullptr;
                //该右节点的左节点的左节点成为旋转节点的右子节点
                assistNode->lNode->parent = currentNode;//因为后面重新赋值了assistNode->lNode,所以不需要置空
                currentNode->rNode = assistNode->lNode;
            }
            //当该右节点的左节点的右节点不为空 
            else {
                //该右节点的左节点的右节点替代旋转节点
                assistNode = rNode->lNode->rNode;
                rNode->lNode->rNode = nullptr;
                //该右节点的左节点成为旋转节点的右子节点
                rNode->lNode->parent = currentNode;
                currentNode->rNode = rNode->lNode;
                rNode->lNode = nullptr;
            }
            //使用该节点替代旋转节点
            assistNode->parent = currentNode->parent;
            if (currentNode->parent != nullptr) {
                if (currentNode->parent->lNode == currentNode)currentNode->parent->lNode = assistNode;
                else currentNode->parent->rNode = assistNode;
            }
            else this->root = assistNode;
            //该左节点和旋转节点分别成为该节点左右节点
            rNode->parent = assistNode;
            assistNode->rNode = rNode;
            currentNode->parent = assistNode;
            assistNode->lNode = currentNode;
            updateDepth(currentNode->rNode);
            updateDepth(currentNode);
            updateDepth(rNode);
            return updateDepth(assistNode);
        }
    }//当旋转点的右节点的右节点为空,提升右子节点的左子节点(此时右子节点的左子节点必不为空)
    else {
        SimpleAvlTreeNode<T>* assistNode = rNode->lNode;
        //右子节点的左子节点提升到旋转点所在位置
        assistNode->parent = currentNode->parent;
        if (currentNode->parent != nullptr) {
            if (currentNode->parent->lNode == currentNode)currentNode->parent->lNode = assistNode;
            else currentNode->parent->rNode = assistNode;
            //父节点为空说明为root节点
        }
        else this->root = assistNode;
        //断开右子节点的左子节点和右子节点的连接  右子节点的左子节点的左子节点成为旋转点的新右子节点，右子节点的左子节点的右子节点成为右子节点的新左子节点
        currentNode->rNode = assistNode->lNode;
        if (currentNode->rNode != nullptr)currentNode->rNode->parent = currentNode;
        rNode->lNode = assistNode->rNode;
        if (rNode->lNode != nullptr)rNode->lNode->parent = rNode;
        //右子节点成为右子节点的左子节点的新右子节点
        rNode->parent = assistNode;
        assistNode->rNode = rNode;
        //旋转点成为右子节点的左子节点的新左子节点
        currentNode->parent = assistNode;
        assistNode->lNode = currentNode;
        updateDepth(currentNode);
        updateDepth(rNode);
        return updateDepth(assistNode);
    }
}
//更新深度信息
template <typename T>
SimpleAvlTreeNode<T>* SimpleAvlTree<T>::updateDepth(SimpleAvlTreeNode<T> *currentNode){
    int lNodeDepth = currentNode->lNode == nullptr ? 0 : currentNode->lNode->depth;
    int rNodeDepth = currentNode->rNode == nullptr ? 0 : currentNode->rNode->depth;
    int maxDepth = lNodeDepth >= rNodeDepth ? lNodeDepth : rNodeDepth;
    int depthOffset = lNodeDepth - rNodeDepth;
    //左边的深度高出1以上,左旋
    if(depthOffset > 1){
        return rRotate(currentNode);
    }
    else if(depthOffset < -1){
        return lRotate(currentNode);
        //终止条件,当前的depth数据正确并不合理,可能当前节点的depth数据正确但上层的depth数据不正确
        //改为一直更新到根节点
    }
    else {
        currentNode->depth = maxDepth + 1;
        return currentNode->parent;
    }
}
//删除节点
//删除非叶子节点，该节点既有左孩子，又有右孩子。操作：该节点的值替换为该节点的前驱节点（或者后继节点），然后删除前驱节点（或者后继节点）
template <typename T>
void SimpleAvlTree<T>::removeNode(SimpleAvlTreeNode<T>* currentNode) {
    if (currentNode != nullptr) {
        //保留父节点
        SimpleAvlTreeNode<T>* assistNode = currentNode->parent;
        SimpleAvlTreeNode<T>* nextNode = nullptr;
        if (currentNode->lNode != nullptr && currentNode->rNode != nullptr) {
            //找前驱节点
            SimpleAvlTreeNode<T>* frontDriveNode = currentNode->lNode;
            while (frontDriveNode->rNode != nullptr) {
                frontDriveNode = frontDriveNode->rNode;
            }
            //保留currentNode但更新数据信息
            currentNode->data = frontDriveNode->data;
            removeNode(frontDriveNode);
            return;//跳过删除当前节点
        }
        else if (currentNode->lNode != nullptr && currentNode->rNode == nullptr) {
            //如果父节点为空则不需要更新父节点信息  但需要更新root
            if (assistNode != nullptr) {
                //连接需要双向更新
                if (assistNode->lNode == currentNode)assistNode->lNode = currentNode->lNode;
                else assistNode->rNode = currentNode->lNode;
                currentNode->lNode->parent = assistNode;
                //更新父节点深度信息
                nextNode = updateDepth(assistNode);
                while (nextNode != nullptr) {
                    nextNode = updateDepth(nextNode);
                }
            }
            else {
                //连接需要双向更新
                this->root = currentNode->lNode;
                currentNode->lNode->parent = nullptr;
            }
        }//如果某个节点为空,则只要用非空子节点代替被删除的节点
        else if (currentNode->lNode == nullptr && currentNode->rNode != nullptr) {
            //如果父节点为空则不需要更新父节点信息  但需要更新root
            if (assistNode != nullptr) {
                //连接需要双向更新
                if (assistNode->lNode == currentNode)assistNode->lNode = currentNode->rNode;
                else assistNode->rNode = currentNode->rNode;
                currentNode->rNode->parent = assistNode;
                //更新父节点深度信息
                nextNode = updateDepth(assistNode);
                while (nextNode != nullptr) {
                    nextNode = updateDepth(nextNode);
                }
            }
            else {
                //连接需要双向更新
                this->root = currentNode->rNode;
                currentNode ->rNode->parent = nullptr;
            }
        }//如果两个子节点均空,说明为叶子节点,直接删除后更新深度信息
        else {
            //如果父节点为空则不需要更新父节点信息  但需要更新root
            if (assistNode != nullptr) {
                if (assistNode->lNode == currentNode)assistNode->lNode = nullptr;
                else assistNode->rNode = nullptr;
                //更新父节点深度信息
                nextNode = updateDepth(assistNode);
                while (nextNode != nullptr) {
                    nextNode = updateDepth(nextNode);
                }
            }
            else this->root = nullptr;
        }
        //删除当前节点
        delete currentNode;
    }
}
template <typename T>
void SimpleAvlTree<T>::removeNode(T data) {
    if (this->root == nullptr)return ;
    else {
        SimpleAvlTreeNode<T>* node = getNode(data);
        if (node != nullptr)removeNode(node);
    }
}
//获取特定节点
template <typename T>
SimpleAvlTreeNode<T>* SimpleAvlTree<T>::getNode(T data) {
    if (this->root == nullptr)return nullptr;
    else {
        SimpleAvlTreeNode<T>* currentNode = this->root;
        //遍历AVL树,找到匹配的节点
        while (true) {
            if (data == currentNode->data) {
                return currentNode;
            }
            else if (data > currentNode->data) {
                if (currentNode->rNode != nullptr)currentNode = currentNode->rNode;
                else return nullptr;
            }
            else {
                if (currentNode->lNode != nullptr)currentNode = currentNode->lNode;
                else return nullptr;
            }
        }
    }
}
//增加节点
template <typename T>
void SimpleAvlTree<T>::addNode(T data){
    if(this->root == nullptr){//默认单个节点深度为0
        this->root = new SimpleAvlTreeNode<T>(data, 1, nullptr, nullptr, nullptr);
    }else {
        SimpleAvlTreeNode<T> *currentNode = this->root;
        SimpleAvlTreeNode<T>* nextNode = nullptr;
        while(true){
            //比较该数据与当前节点的数值
            if(data >= currentNode->data){
                //如果大于等于且当前节点右值为空,插入
                if(currentNode->rNode == nullptr){
                    currentNode->rNode = new SimpleAvlTreeNode<T>(data, 1, currentNode, nullptr, nullptr);
                    nextNode = updateDepth(currentNode);
                    while (nextNode != nullptr) {
                        nextNode = updateDepth(nextNode);
                    }
                    return ;
                }else currentNode = currentNode->rNode;//如果大于等于但当前节点右值非空,继续比较
            }else {
                //如果大于等于且当前节点左值为空,插入
                if(currentNode->lNode == nullptr){
                    currentNode->lNode = new SimpleAvlTreeNode<T>(data, 1, currentNode, nullptr, nullptr);
                    nextNode = updateDepth(currentNode);
                    while (nextNode != nullptr) {
                        nextNode = updateDepth(nextNode);
                    }
                    return ;
                    //如果大于等于但当前节点左值非空,继续比较
                }else currentNode = currentNode->lNode;
            }
        }
    }
}
class SimpleIntAvlTree : public SimpleAvlTree<int>{
public:
    void iteratorTreeString(SimpleAvlTreeNode<int> *currentNode);
    char *toString();
    char *depthToString();
    SimpleIntAvlTree(){}
    ~SimpleIntAvlTree(){}
};
void SimpleIntAvlTree::iteratorTreeString(SimpleAvlTreeNode<int> *currentNode){
    if(currentNode->lNode != nullptr)iteratorTreeString(currentNode->lNode);
    std::cout << currentNode->data;
    if(currentNode->rNode != nullptr)iteratorTreeString(currentNode->rNode);
}
char *SimpleIntAvlTree::toString(){
    if (root == nullptr) {
        SimpleString str = SimpleString("空树");
        return str.getData();
    }
    SimpleQueue<SimpleAvlTreeNode<int> *> *ss = new SimpleQueue<SimpleAvlTreeNode<int> *>();
    SimpleQueue<SimpleAvlTreeNode<int> *> *ssNext = new SimpleQueue<SimpleAvlTreeNode<int> *>();
    SimpleQueue<SimpleAvlTreeNode<int> *> *temp = nullptr;
    SimpleAvlTreeNode<int> *n = nullptr;
    ss->push(root);
    SimpleStringBuilder strBuilder;
    SimpleString layerInsideGap = SimpleString(" ");
    SimpleString layerGap = SimpleString("\n");
    while(true){
        while(!ss->isEmpty()){
            n = ss->pop_back();
            if(n->lNode != nullptr)ssNext->push(n->lNode);
            if(n->rNode != nullptr)ssNext->push(n->rNode);
            SimpleString data = SimpleString((long)n->data);
            strBuilder.append(layerInsideGap);
            strBuilder.append(data);
        }
        if(!ssNext->isEmpty()){
            temp = ss;
            ss = ssNext;
            ssNext = temp;
            strBuilder.append(layerGap);
        }else break;
    }
    int length = strBuilder.getLength();
    char *s = new char[length + 1];
    memcpy(s, strBuilder.getData(), length);
    s[length] = 0;
    //释放空间
    delete ss;
    delete ssNext;
    return s;
}
char *SimpleIntAvlTree::depthToString(){
    if (root == nullptr) {
        SimpleString str = SimpleString("空树");
        return str.getData();
    }
    SimpleQueue<SimpleAvlTreeNode<int> *> *ss = new SimpleQueue<SimpleAvlTreeNode<int> *>();
    SimpleQueue<SimpleAvlTreeNode<int> *> *ssNext = new SimpleQueue<SimpleAvlTreeNode<int> *>();
    SimpleQueue<SimpleAvlTreeNode<int> *> *temp = nullptr;
    SimpleAvlTreeNode<int> *n = nullptr;
    ss->push(root);
    SimpleStringBuilder strBuilder;
    SimpleString layerInsideGap = SimpleString(" ");
    SimpleString layerGap = SimpleString("\n");
    while(true){
        while(!ss->isEmpty()){
            n = ss->pop_back();
            if(n->lNode != nullptr)ssNext->push(n->lNode);
            if(n->rNode != nullptr)ssNext->push(n->rNode);
            SimpleString data = SimpleString((long)n->depth);
            strBuilder.append(layerInsideGap);
            strBuilder.append(data);
        }
        if(!ssNext->isEmpty()){
            temp = ss;
            ss = ssNext;
            ssNext = temp;
            strBuilder.append(layerGap);
        }else break;
    }
    int length = strBuilder.getLength();
    char *s = new char[length + 1];
    memcpy(s, strBuilder.getData(), length);
    s[length] = 0;
    //释放空间
    delete ss;
    delete ssNext;
    return s;
}
#endif // SIMPLEAVLTREE_H
蔡海航
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
AVL树和红黑树
weixin_59371851的博客
09-18 872
哈喽，小伙伴们大家好。之前我们介绍了二叉搜索树用于搜索数据，但是二叉搜索树具有一些缺陷，比如在大多数节点的子节点都只有一个时，那搜索二叉树就会近似成一条线，搜索的时间复杂度就会从O(logN)退化成O(N)。针对这个问题，一些人对二叉搜索树进行了升级改造，也就是我们今天要学习的AVL树与红黑树。一、AVL树我们定义AVL树的节点时，不但有左右指针，为了方便还增加了父节点的指针。其中bf代表平衡因子。//banlance factor 平衡因子。
BST_Dictionary：基于AVL树的简单拼写检查器
02-21
BST_Dictionary 一个基于AVL树的基本拼写检查器实现。 您可以在找到更多详细信息检查一下 :backhand_index_pointing_right:
【 C++ 】AVL树
bit_zyx的博客
09-04 811
目录 1、底层结构 2、AVL树的概念 3、AVL树节点的定义 4、基本框架 5、AVL树的插入 6、AVL树的旋转 左单旋 右单旋 左右双旋 右左双旋 7、AVL树的验证 8、AVL树的查找 9、AVL树的删除（了解） 10、AVL树的性能 11、源码链接.........
AVL树（动图详解）
热门推荐
2021dragon的博客
12-02 1万+
AVL树（C++实现）
数据结构：AVL树
decade777555的博客
03-07 1207
两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右 子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
AVL树的 插入 和 删除
潜心钻研技术
03-11 1766
AVL树的 插入 和 删除
AVL树详解
北川_的博客
03-09 1570
目录AVL树的概念AVL树节点的定义AVL树如何高度平衡？右单旋左单旋左右双旋 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。 因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)， 即可降低树的高度，从而减少平均搜索长度。 AVL
Java手写AVL树（非常详细）
fengxiandada的博客
04-08 2648
文章目录1. 二叉搜索树复杂度2. BST的平衡3. 改进二叉搜索树4. 平衡二叉搜索树（Balanced Binary Search Tree）5. AVL树5.1 AVL树的相关概念及特点5.2 普通BST和AVL树添加对比6. AVL树设计6.1 继承结构6.2 普通BST添加导致失衡例子6.3 解决添加失衡——LL-右旋转(单旋)6.4 解决添加失衡——RR-左旋转(单旋)6.5 解决添加失衡——LR-RR左旋转，LL右旋转(双旋)6.6 解决添加失衡——RL-LL右旋转，RR左旋转(双旋)6.7
有序表之AVL树
明朗晨光的专栏
02-13 286
1、何为有序表 ；2、AVL树失衡类型(LL/LR/RR/RL)以及AVL树平衡性的调整；3、AVL树实现有序表
AVL树的实现
qq_52145272的博客
06-22 232
AVL树的插入、旋转和验证等代码实现
AVL树的插入详解
C_Rio的博客
11-09 281
_kv(kv)//pair内部有实现自己的拷贝构造函数,_bf(0){}int _bf;//每个节点的平衡因子（right-left）class AVLpublic:AVL(){}private:首先我们要知道AVL树的数据类型一般都是K-V型，具体说也就是pair类型，而且AVL树和一般的树据关联是不同的，属于三叉连，也就是不仅仅要有左右指针还要有父指针，而父指针的目的就是在插入数据的时候可以更方便的处理祖宗节点的平衡因子。平衡因子的计算：右子树的高度—左子树的高度。
一个简单的 AVL树、splay树、以及二叉搜索树的代码实现
05-04
一个简单的 AVL树、splay树、以及二叉搜索树的代码实现 也可在我的github仓库中下载： https://github.com/yunwei37/myClassNotes
AVL-tree:简单的avl树字典
06-10
AVL树简易育种树字典
AVL树的完整实现（含比较器，Java语言描述）
12-22
AVL树作为数据结构，说简单也简单，说复杂也复杂。对初学者来说，一定要掌握的是检测和调整AVL树平衡（含四种旋转）的代码，随着学习的深入，应该尝试编写AVL树的完整代码。 这里就给大家提供一份可用
AVLBaum:Java中AVL树的表示
06-20
本项目是一个示例项目，展示了如何在 BlueJ 等简单的编程环境中使用 Java 实现一个 AVL 二叉搜索树。 ###用作图书馆 可以通过实现IData接口来添加数据 BinaryTree是一种基本的二叉搜索树，它以排序的方式插入元素 ...
数据结构（DS）学习笔记（4）：线性表
最新发布
她与剑意皆失的博客
06-13 457
线性表是最常用且最简单的一种数据结构，是一种典型的线性结构，一个线性表是n个数据元素的有限序列。除了第一个元素外，每个元素有且仅有一个直接前趋；除了最后一个元素外，每个元素有且仅有一个直接后继。同一个线性表中的元素必定具有相同特征，数据元素之间的关系是线性关系。线性表中每个数据元素所占的空间是一样大的。线性表的顺序表示：顺序存储结构或顺序映象。线性表的顺序表示：指的是用同一组地址连续的存储单元依次存储线性表的数据元素。顺序存储定义：把逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构。线性表逻辑结构
数据结构逻辑
qq_42129915的博客
06-10 286
1、线性关系2：树型关系3：图像关系。
如何使用Python中的collections模块提供的数据结构，如deque、Counter、OrderedDict等
2402_84885073的博客
06-09 374
Python 的模块提供了一些额外的数据结构，这些数据结构在内置的数据类型（如列表、字典、集合等）的基础上，增加了额外的功能或优化了性能。下面是如何使用模块中的dequeCounter和这三种数据结构的简单示例。
【算法】常用排序算法（插入排序、希尔排序、堆排序、选择排序、冒泡排序、快速排序、归并排序、计数排序）超详细
abcwyffff的博客
06-09 1038
排序算法是数据结构相关知识中非常重要的一节，相信很多小伙伴对这部分知识一知半解。那么接下来，小编就要带领大家一起来进行对排序算法的深入剖析学习，希望本篇文章能够使你有所收获！
avl树c++
05-24
下面是一个简单的AVL树的C++实现： ```c++ #include using namespace std; // AVL树节点 struct Node { int key; int height; Node *left; Node *right; Node(int k) : key(k), height(1), left(NULL), ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

蔡海航

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

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

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

打赏作者

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

抵扣说明：

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

余额充值