码迷，mamicode.com
首页 > 编程语言 > 详细

C++类实现AVL树

时间：2016-05-21 06:36:33      阅读：274      评论：0      收藏：0      [点我收藏+]

标签：

二叉查找树是个好东西，他让查找，插入，删除，这些常用操作变得高效，但是，他是存在问题的，那就是，在坏的输入序列下，树会退化成链表，这就很尴尬了，于是为了避免这种情况的发生，我们需要一种数据结构，可以自动对树进行调整，我们希望树尽量平衡，于是我们使用平衡因子作为指标，保持任意节点左右子树深度差不超过1，这就可以让树的深度很理想了（接近log2N)，如何对树进行调整呢？我们通过旋转来完成他。

技术分享 
#include <iostream>
#include <queue>

class AVLT{//小于向左，大于等于向右,元素类型需支持 <
private:
    typedef int Element;
    struct AVLTNode{
        Element data;
        AVLTNode *left;
        AVLTNode *right;
        int Deepth;
        AVLTNode();
        ~AVLTNode();
        bool isLeaf()const;
        void nodeInsect(const Element &e);
        void nodeDelete(const Element &e);
        const AVLTNode *Find(const Element &e)const;
        const Element& Min()const;
        const Element& Max()const;
        void nodeTraverseFrist(std::ostream& os = std::cout)const;
        void nodeTraverseMid(std::ostream& os = std::cout)const;
        void nodeTraverseLast(std::ostream& os = std::cout)const;
        void nodeTraverselevel(std::ostream& os = std::cout)const;
        const AVLTNode & operator =(const AVLTNode &T);
        void swapdata(AVLTNode&a, AVLTNode&b)const;
        void SingleLeftRotation();
        void SingleRightRotation();
        void DoubleRightLeftRotation();
        void DoubleLeftRightRotation();
        inline void renewDeepth();
        inline int max(int a, int b)const;
    };
    AVLTNode *node;
    int number_of_Node;
public:
    AVLT();
    AVLT(Element *arr, int size); 
    AVLT(const AVLT &T);
    ~AVLT(); 
    bool empty()const; 
    const Element& Max()const;  
    const Element& Min()const;
    const AVLT &operator = (const AVLT&T); 
    void TraverseFrist(std::ostream& os = std::cout)const;
    void TraverseLast(std::ostream& os = std::cout)const;
    void TraverseMid(std::ostream& os = std::cout)const;
    void Traverselevel(std::ostream& os = std::cout)const;
    void Insect(const AVLT::Element &e); 
    bool Delete(const AVLT::Element &e);
    int Deepth();
    int Node();
    const AVLTNode* find(const Element &e)const;
};

AVLT::AVLTNode::AVLTNode():left(NULL), right(NULL), Deepth(0){}
AVLT::AVLTNode::~AVLTNode(){
    delete left;
    delete right;
}
bool AVLT::AVLTNode::isLeaf()const{
    return left == NULL&&right == NULL;
}
void AVLT::AVLTNode::nodeInsect(const Element &e){
    if (Deepth == 0){
        Deepth = 1;
        data = e;
        return;
    }
    if (e<data){
        if (left == NULL){
            left = new AVLTNode;
        }
        left->nodeInsect(e);
        if (right){
            if (left->Deepth - right->Deepth > 1){
                if (e<left->data){
                    this->SingleRightRotation();
                }
                else{
                    this->DoubleLeftRightRotation();
                }
            }
        }
        else{
            if (left->Deepth > 1){
                if (e<left->data){
                    this->SingleRightRotation();
                }
                else{
                    this->DoubleLeftRightRotation();
                }
            }
        }
        renewDeepth();
    }
    else{
        if (right == NULL){
            right = new AVLTNode;
        }
        right->nodeInsect(e);
        if (left){
            if (right->Deepth - left->Deepth > 1){
                if (e<right->data){
                    this->DoubleRightLeftRotation();
                }
                else{
                    this->SingleLeftRotation();
                }
            }
        }
        else{
            if (right->Deepth > 1){
                if (e<right->data){
                    this->DoubleRightLeftRotation();
                }
                else{
                    this->SingleLeftRotation();
                }
            }
        }
        renewDeepth();
    }
    return;
}
void AVLT::AVLTNode::nodeDelete(const Element &e){
    if (e<data){
        if (left){
            if (left->isLeaf()){
                delete left;
                left = NULL;
            }
            else
                left->nodeDelete(e);
            {
                int rd = right ? right->Deepth : 0;
                int ld = left ? left->Deepth : 0;
                if (rd - ld >1){
                    if (right->left){
                        DoubleRightLeftRotation();
                    }
                    else{
                        SingleLeftRotation();
                    }
                }
                renewDeepth();
            }
        }
        return;
    }
    else{
        if (data<e){
            if (right){
                if (right->isLeaf()){
                    delete right;
                    right = NULL;
                }
                else
                    right->nodeDelete(e);
                {
                    int rd = right ? right->Deepth : 0;
                    int ld = left ? left->Deepth : 0;
                    if (ld - rd >1){
                        if (left->right){
                            DoubleLeftRightRotation();
                        }
                        else{
                            SingleRightRotation();
                        }
                    }
                    renewDeepth();
                }
                return;
            }
        }
        else{
            if (left == NULL&&right){
                AVLTNode *t = right;
                if (left)
                    delete left;
                left = t->left;
                right = t->right;
                data = t->data;
                Deepth -= 1;
                t->left = t->right = NULL;
                delete t;
                return;
            }
            else{
                if (right == NULL && left){
                    AVLTNode *t = left;
                    if (right)
                        delete right;
                    right = t->right;
                    left = t->left;
                    data = t->data;
                    Deepth -= 1;
                    t->left = t->right = NULL;
                    delete t;
                    return;
                }
                else{

                    AVLTNode *t = left;
                    while (t->right)
                        t = t->right;
                    Element te = t->data;
                    if (left->isLeaf()){
                        delete left;
                        left = NULL;
                    }
                    else
                        left->nodeDelete(te);
                    data = te;
                    return;
                }
            }
        }
    }
    std::cout << "return false" << std::endl;
    return;
}
AVLT::AVLTNode const *AVLT::AVLTNode::Find(const Element &e)const{
    if (e<data){
        if (left)
            return left->Find(e);
    }
    else{
        if (data<e){
            if (right)
                return right->Find(e);
        }
        else{
            return this;
        }
    }
    return NULL;
}
const AVLT::Element& AVLT::AVLTNode::Max()const{
    const AVLTNode *t = this;
    while (t->right)
        t = t->right;
    return t->data;
}
const AVLT::Element& AVLT::AVLTNode::Min()const{
    const AVLTNode *t = this;
    while (t->left)
        t = t->left;
    return t->data;
}
void AVLT::AVLTNode::nodeTraverseFrist(std::ostream& os)const{
    os << this->data << ‘ ‘;
    if (left)
        this->left->nodeTraverseFrist();
    if (right)
        this->right->nodeTraverseFrist();
}
void AVLT::AVLTNode::nodeTraverseMid(std::ostream& os )const{
    if (left)
        this->left->nodeTraverseMid();
    os << this->data << ‘ ‘;
    if (right)
        this->right->nodeTraverseMid();
}
void AVLT::AVLTNode::nodeTraverseLast(std::ostream& os )const{
    if (left)
        this->left->nodeTraverseLast();
    if (right)
        this->right->nodeTraverseLast();
    os << this->data << ‘ ‘;
}
void AVLT::AVLTNode::nodeTraverselevel(std::ostream& os)const{
    std::queue<AVLTNode> q;
    q.push(*this);
    while (!q.empty()){
        AVLTNode p = q.front();
        q.pop();
        os << p.data << ‘ ‘;
        if (p.left){
            q.push(*(p.left));
        }
        if (p.right){
            q.push(*(p.right));
        }
    }
}
const AVLT::AVLTNode & AVLT::AVLTNode::operator =(const AVLTNode &T){
    if (Deepth == 0){
        Deepth = 1;
        data = T.data;
    }
    if (T.left){
        if (left == NULL){
            left = new AVLTNode;
        }
        *left = *T.left;
        if (right){
            Deepth = max(left->Deepth, right->Deepth) + 1;
        }
        else{
            Deepth = left->Deepth + 1;
        }
    }
    if (T.right){
        if (right == NULL){
            right = new AVLTNode;
        }
        *right = *T.right;
        if (left){
            Deepth = max(left->Deepth, right->Deepth) + 1;
        }
        else{
            Deepth = right->Deepth + 1;
        }
    }
    return *this;
}
void AVLT::AVLTNode::swapdata(AVLTNode&a, AVLTNode&b)const{
    Element t;
    t = a.data;
    a.data = b.data;
    b.data = t;
}
void AVLT::AVLTNode::SingleLeftRotation(){
    AVLTNode *a = right;
    right = a->right;
    a->right = a->left;
    a->left = left;
    left = a;
    if (a->right&&a->left){
        a->Deepth = max(a->left->Deepth, a->right->Deepth) + 1;
    }
    else
        if (a->left){
            a->Deepth = a->left->Deepth + 1;
        }
        else{
            a->Deepth = 1;
        }
        swapdata(*this, *a);
}
void AVLT::AVLTNode::SingleRightRotation(){
    AVLTNode *a = left;
    left = a->left;
    a->left = a->right;
    a->right = right;
    right = a;
    if (a->right&&a->left){
        a->Deepth = max(a->left->Deepth, a->right->Deepth) + 1;
    }
    else
        if (a->left){
            a->Deepth = a->left->Deepth + 1;
        }
        else{
            a->Deepth = 1;
        }
        swapdata(*this, *a);
}
void AVLT::AVLTNode::DoubleLeftRightRotation(){
    this->left->SingleLeftRotation();
    this->SingleRightRotation();
}
void AVLT::AVLTNode::DoubleRightLeftRotation(){
    this->right->SingleRightRotation();
    this->SingleLeftRotation();
}
inline void AVLT::AVLTNode::renewDeepth(){
    Deepth = max(left ? left->Deepth : 0, right ? right->Deepth : 0) + 1;
}
inline int AVLT::AVLTNode::max(int a, int b)const{
    return a > b ? a : b;
}

AVLT::AVLT():node(NULL), number_of_Node(0){
}
AVLT::AVLT(Element *arr, int size) : node(NULL), number_of_Node(0){
    node = new AVLTNode;
    for (int i = 0; i < size; i++)
        this->Insect(arr[i]);
}
AVLT::AVLT(const AVLT &T) : node(NULL), number_of_Node(0){
    *this = T;
}
AVLT::~AVLT(){
    delete node;
}
bool AVLT::empty()const{
    return node == NULL;
}
const AVLT::Element& AVLT::Max()const{
    return node->Max();
}
const AVLT::Element& AVLT::Min()const {
    return node->Min();
}
const AVLT &AVLT::operator = (const AVLT&T){
    delete node;
    node = new AVLTNode;
    number_of_Node = T.number_of_Node;
    *node = *T.node;
    return *this;
}
void AVLT::TraverseFrist(std::ostream& os )const{
    if (node)
        node->nodeTraverseFrist(os);
}
void AVLT::TraverseLast(std::ostream& os )const{
    if (node)
        node->nodeTraverseLast(os);
}
void AVLT::TraverseMid(std::ostream& os )const{
    if (node)
        node->nodeTraverseMid(os);
}
void AVLT::Traverselevel(std::ostream& os )const{
    if (node)
        node->nodeTraverselevel(os);
}
void AVLT::Insect(const AVLT::Element &e){
    number_of_Node++;
    if (node == NULL){
        node = new AVLTNode;
    }
    node->nodeInsect(e);
}
bool AVLT::Delete(const AVLT::Element &e){
    if (node){
        if (node->isLeaf()){
            delete node;
            node = NULL;
        }
        else
            node->nodeDelete(e);
        number_of_Node--;
        return true;
    }
    else{
        return false;
    }
}
int AVLT::Deepth(){
    return node->Deepth;
}
int AVLT::Node(){
    return number_of_Node;
}
const AVLT::AVLTNode*AVLT::find(const AVLT::Element &e)const {
    if (node)
        return node->Find(e);
    else
        return NULL;;
}
std::ostream& operator << (std::ostream& os, const AVLT& T){
    T.TraverseFrist(os);
    return os;
}
const AVLT& find();
View Code

这样看上去，AVL树似乎完胜普通的二叉查找树，但是现实是，坏的序列往往很少出现，很多时候，普通二叉树因为不需要判断平衡因子，旋转这些操作，效率反而更高，但是他一旦对上坏的序列就无计可施了，想能防住坏的序列，但又不想每次都旋转，于是就有伸展树这种数据结构，他只在坏的序列出现时旋转，但是只有“坏到一定

程度才旋转”，于是会出现比较坏但坏得不彻底的尴尬情况，伸展树无法保证每次操作都是O（log2N)，但是能保证M次操作时间复杂度为O（Mlog2N）。

C++类实现AVL树

标签：

原文地址：http://www.cnblogs.com/Dadio/p/5513883.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！