AVLTree的实作

最新推荐文章于 2023-06-26 01:10:55 发布
最新推荐文章于 2023-06-26 01:10:55 发布
阅读量547 收藏
点赞数
分类专栏： C++ 文章标签： class iterator null reference delete struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daeees/article/details/4321865
版权

#ifndef _KOK_AVLTREE_H_
#define _KOK_AVLTREE_H_
#pragma once

#include "Alloc.h"
#include "Utility.h"

namespace KOK
{
    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc = KOK::alloc>
    class CAVLTree
    {
        enum __Balance { L = 1, B = 0, R = -1, H = 99};

        template <class NodeValue>
        struct CAVLTreeNode
        {
            typedef CAVLTreeNode<NodeValue>* LinkType;
            LinkType pParent;
            LinkType pLeft;
            LinkType pRight;
            __Balance balance;
            NodeValue value;

            static LinkType Minimun(LinkType x)
            {
                while(x->pLeft != NULL)
                {
                    x = x->pLeft;
                }
                return x;
            }
            static LinkType Maximun()
            {
                while(x->pRight != NULL)
                {
                    x = x->pRight;
                }
                return x;
            }

        };

    public:
        template <class V, class R, class P>
        struct CAVLTreeIterator
        {
            typedef V ValueType;
            typedef R Reference;
            typedef P Pointer;
            typedef CAVLTreeNode<ValueType>* LinkType;
            typedef CAVLTreeIterator<ValueType, Reference, Pointer> Self;
            typedef CAVLTreeIterator<Value, Value&, Value*> Iterator;
            typedef CAVLTreeIterator<Value, const Value&, const Value*> ConstIterator;

        private:
            LinkType pNode_;

        private:
            void Increment()
            {
                if(pNode_->balance == __Balance::H)
                    pNode_ = pNode_;
                else if(pNode_->pRight)
                {
                    pNode_ = pNode_->pRight;
                    while(pNode_->pLeft)
                        pNode_ = pNode_->pLeft;
                }
                else
                {
                    LinkType pParent = pNode_->pParent;
                    while(pParent->pRight == pNode_)
                    {
                        pNode_ = pParent;
                        pParent = pParent->pParent;
                    }
                    if(pNode_->pRight != pParent)
                        pNode_ = pParent;
                }
            }

            void Decrement()
            {
                if(pNode_->balance == __Balance::H)
                    pNode_ = pNode_->pRight;
                else if(pNode_->pLeft)
                {
                    pNode_ = pNode_->pLeft;
                    while(pNode_->pRight)
                        pNode_ = pNode_->pRight;
                }
                else
                {
                    LinkType pParent = pNode_->pParent;
                    while(pParent->pLeft == pNode_)
                    {
                        pNode_ = pParent;
                        pParent = pParent->pParent;
                    }

                    pNode_ = pParent;
                }
            }

        public:
            CAVLTreeIterator(const LinkType& pNode) //const is not necessory.LinkType is seem like a value type after typedef. Const is not necessory in value type coz temperarily copy. see blog topic "const and typedef"
            {
                this->pNode_ = pNode;
            }

            Self& operator ++()
            {
                Increment();
                return *this;
            }

            Self& operator ++(int)
            {
                Self temp = *this;
                Increment();
                return temp;
            }

            Self& operator --()
            {
                Decrement();
                return *this;
            }

            Self& operator --(int)
            {
                Self temp = *this;
                Decrement();
                return temp;
            }

            Reference operator *() const
            {
                return pNode_->value;
            }

            Pointer operator ->() const
            {
                return &pNode_->value;
            }

            bool operator ==(const Self& other)
            {
                return (&other)->pNode_ == this->pNode_;
            }

            bool operator !=(const Self& other)
            {
                return !operator==(other);
            }

        };

    private:
        typedef CAVLTreeNode<Value> Node;
        typedef KOK::CAllocAdapter<Node, Alloc> NodeAlloc;

    public:
        typedef Key KeyType;
        typedef Value ValueType;
        typedef Value* Pointer;
        typedef const Value* ConstPointer;
        typedef Value& Reference;
        typedef const Value& ConstReference;
        typedef size_t SizeType;
        typedef ptrdiff_t DiffType;

        typedef CAVLTreeIterator<ValueType, Reference, Pointer> Iterator;

    protected:
        typedef CAVLTreeNode<Value>* LinkType;

    protected:
        SizeType count_;
        Compare compare_;
        LinkType pHeader_;
        KeyOfValue keyOfValue_;

    protected:
        void RotateLeft(LinkType& pRoot);
        void RotateRight(LinkType& pRoot);
        void LeftBalance(LinkType& pRoot);
        void RightBalance(LinkType& pRoot);
        void DelLeftAdjust(LinkType& pNode);
        void DelRightAdjust(LinkType& pNode);

        void DeleteNode(LinkType& pNode)
        {
            Destroy(&pNode->value);
            PutNode(pNode);
            pNode = NULL;
        }
        LinkType CreateNode(ConstReference value)
        {
            LinkType pNode = GetNode();
            pNode->pLeft = pNode->pRight = pNode->pParent = NULL;
            pNode->balance = __Balance::B;
            Construct(&pNode->value, value);
            return pNode;
        }
        LinkType GetNode() { return NodeAlloc::Allocate();}
        void PutNode(LinkType pNode) { NodeAlloc::Deallocate(pNode); }

        void DeleteAux(LinkType& pNode, ConstReference value, bool& shorter);
        int InnerDelete(LinkType& pNode, ConstReference value, bool& shorter);
        Pair<typename Iterator, bool> InsertAux(LinkType& pRoot, LinkType& pParent, ConstReference value, bool& taller, bool isUnique);

        inline LinkType& LeftMost() const { return pHeader_->pLeft; }
        inline LinkType& RightMost() const { return pHeader_->pRight; }
        inline LinkType& Root() const { return pHeader_->pParent; }

        void Init();
        void ClearAux(LinkType& pNode);
    public:
        CAVLTree();
        ~CAVLTree();

        Pair<Iterator, bool> InsertUnique(ConstReference value);
        Iterator InsertEqual(ConstReference value);
        int Delete(ConstReference value);
        void Clear();
        Iterator Find(const KeyType& key);

        inline KeyOfValue GetKeyOfValue() const { return keyOfValue_; }
        inline Compare GetCompare() const { return compare_; }

        inline SizeType GetSize() const { return count_; }
        inline ValueType MaxValue() const { return RightMost()->value; }
        inline ValueType MinValue() const { return LeftMost()->value; }

        inline Iterator Begin() const { return LeftMost(); }
        inline Iterator End() const { return pHeader_; }
        inline bool Empty() const { return count_ == 0;}

    private:
        CAVLTree& operator =(const CAVLTree&);
        CAVLTree(const CAVLTree&);

    };

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    void CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::Init()
    {
        pHeader_ = GetNode();
        pHeader_->balance = __Balance::H;
        pHeader_->pLeft = pHeader_->pRight = pHeader_;
        pHeader_->pParent = NULL;
        count_ = 0;

    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    void CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::ClearAux(LinkType& pNode)
    {
        if(pNode->pLeft != NULL)
            ClearAux(pNode->pLeft);
        if(pNode->pRight != NULL)
            ClearAux(pNode->pRight);
        DeleteNode(pNode);
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    void CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::Clear()
    {
        if(Empty())
            return;
        ClearAux(Root());
        RightMost() = LeftMost() = NULL;
        count_ = 0;
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    typename CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::Iterator CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::Find(const KeyType& key)
    {
        LinkType y = pHeader_;
        LinkType x = Root();
        while(x != NULL)
        {
            if(!compare_(keyOfValue_(x->value), key))
            {
                y = x;
                x = x->pLeft;
            }
            else
            {
                x = x->pRight;
            }

        }
        Iterator i = Iterator(y);
        return i == End() || compare_(key, keyOfValue_(y->value)) ? End() : i;
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::CAVLTree()
    {
        Init();
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::~CAVLTree()
    {
        Clear();
        PutNode(pHeader_);

    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    void CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::RotateLeft(LinkType &pRoot)
    {
        LinkType pLeft = pRoot;
        pRoot = pRoot->pRight;
        pRoot->pParent = pLeft->pParent;
        pLeft->pRight = pRoot->pLeft;
        if(pRoot->pLeft)
            pRoot->pLeft->pParent = pLeft;
        pRoot->pLeft = pLeft;
        pLeft->pParent = pRoot;
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    void CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::RotateRight(LinkType &pRoot)
    {
        LinkType pRight = pRoot;
        pRoot = pRoot->pLeft;
        pRoot->pParent = pRight->pParent;
        pRight->pLeft = pRoot->pRight;
        if(pRoot->pRight)
            pRoot->pRight->pParent = pRight;
        pRoot->pRight = pRight;
        pRight->pParent = pRoot;
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    void CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::LeftBalance(LinkType &pRoot)
    {
        LinkType pLeft = pRoot->pLeft;
        switch(pLeft->balance)
        {
        case L:
            pRoot->balance = pLeft->balance = B;
            RotateRight(pRoot);
            break;
        case R:
            {
                LinkType pRChild = pLeft->pRight;
                switch(pRChild->balance)
                {
                case L:
                    pLeft->balance = B;
                    pRoot->balance = R;
                    break;
                case B:
                    pLeft->balance = pRoot->balance = B;
                    break;
                case R:
                    pRoot->balance = B;
                    pLeft->balance = L;
                    break;
                }
                pRChild->balance = B;
                RotateLeft(pLeft);
                RotateRight(pRoot);
                break;
            }
        case B:
            return;
        }
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    void CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::RightBalance(LinkType &pRoot)
    {
        LinkType pRight = pRoot->pRight;
        switch(pRight->balance)
        {
        case R:
            pRoot->balance = pRight->balance = B;
            RotateLeft(pRoot);
            break;
        case L:
            {
                LinkType pLChild = pRight->pLeft;
                switch(pLChild->balance)
                {
                case L:
                    pRight->balance = R;
                    pRoot->balance = B;
                    break;
                case B:
                    pRight->balance = pRoot->balance = B;
                    break;
                case R:
                    pRoot->balance = L;
                    pRight->balance = B;
                    break;
                }
                pLChild->balance = B;
                RotateRight(pRight);
                RotateLeft(pRoot);
                break;
            }
        case B:
            return;
        }
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    Pair<typename CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::Iterator, bool> CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::InsertAux(LinkType& pRoot, LinkType& pParent, ConstReference value, bool& taller, bool isUnique)
    {
        if(pRoot == NULL)
        {
            pRoot = CreateNode(value);
            pRoot->balance = __Balance::B;
            pRoot->pParent = pParent;
            pRoot->pRight= NULL;
            pRoot->pLeft = NULL;
            taller = true;
            count_++;

            if(pParent == LeftMost())
            {
                if(compare_(keyOfValue_(value), keyOfValue_(pParent->value)))
                {
                    LeftMost() = pRoot;
                }
            }

            if(pParent == RightMost())
            {
                if(!compare_(keyOfValue_(value), keyOfValue_(pParent->value)))
                {
                    RightMost() = pRoot;
                }
            }

            return Pair<Iterator, bool>(Iterator(pRoot), true);
        }
        else
        {
            if(compare_(keyOfValue_(pRoot->value), keyOfValue_(value)))
            {
                Pair<Iterator, bool> temp = InsertAux(pRoot->pRight, pRoot, value, taller, isUnique);
                if(!temp.second)
                    return temp;

                if(taller)
                {
                    switch(pRoot->balance)
                    {
                    case R:
                        RightBalance(pRoot);
                        taller = false;
                        break;
                    case B:
                        pRoot->balance = R;
                        taller = true;
                        break;
                    case L:
                        pRoot->balance = B;
                        taller = false;
                        break;
                    }
                }
                return temp;
            }
            else if(compare_(keyOfValue_(value), keyOfValue_(pRoot->value)))
            {
                Pair<Iterator, bool> temp = InsertAux(pRoot->pLeft, pRoot, value, taller, isUnique);
                if(!temp.second)
                    return temp;

                if(taller)
                {
                    switch(pRoot->balance)
                    {
                    case R:
                        pRoot->balance = B;
                        taller = false;
                        break;
                    case B:
                        pRoot->balance = L;
                        taller = true;
                        break;
                    case L:
                        LeftBalance(pRoot);
                        taller = false;
                        break;
                    }
                }
                return temp;
            }
            else
            {
                if(isUnique)
                    return Pair<Iterator, bool>(Iterator(pRoot), false);
                else
                {
                    Pair<Iterator, bool> temp = InsertAux(pRoot->pRight, pRoot, value, taller, isUnique);
                    if(!temp.second)
                        return temp;

                    if(taller)
                    {
                        switch(pRoot->balance)
                        {  
                        case R:
                            RightBalance(pRoot);
                            taller = false;
                            break;
                        case B:
                            pRoot->balance = R;
                            taller = true;
                            break;
                        case L:
                            pRoot->balance = B;
                            taller = false;
                            break;
                        }
                    }

                    return temp;
                }

            }
        }
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    Pair<typename CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::Iterator, bool> CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::InsertUnique(ConstReference value)
    {
        bool taller = false;

        if(Root() == NULL)
        {
            Root() = CreateNode(value);
            Root()->balance = __Balance::B;
            Root()->pParent = pHeader_;
            Root()->pRight= NULL;
            Root()->pLeft = NULL;
            pHeader_->pLeft = pHeader_->pRight = Root();
            taller = true;
            count_++;

            return Pair<Iterator, bool>(Iterator(Root()), true);
        }
        else
        {
            return InsertAux(Root(), pHeader_, value, taller, true);
        }

    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    typename CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::Iterator CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::InsertEqual(ConstReference value)
    {
        bool taller = false;

        if(Root() == NULL)
        {
            Root() = CreateNode(value);
            Root()->balance = __Balance::B;
            Root()->pParent = pHeader_;
            Root()->pRight= NULL;
            Root()->pLeft = NULL;
            pHeader_->pLeft = pHeader_->pRight = Root();
            taller = true;
            count_++;

            return Root();
        }
        else
        {
            return InsertAux(Root(), pHeader_, value, taller, false).first;
        }

    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    void CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::DelLeftAdjust(LinkType& pNode)
    {
        LinkType pLeft = pNode->pLeft;
        switch(pLeft->balance)
        {
        case B:
            pNode->balance = L;
            pLeft->balance = R;
            RotateRight(pNode);
            break;
        case L:
            pLeft->balance = B;
            pNode->balance = B;
            RotateRight(pNode);
            break;
        case R:
            pLeft->balance = B;
            pNode->balance = B;
            RotateLeft(pLeft);
            RotateRight(pNode);
            break;
        }
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    void CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::DelRightAdjust(LinkType& pNode)
    {
        LinkType pRight = pNode->pRight;
        switch(pRight->balance)
        {
        case B:
            pNode->balance = R;
            pRight->balance = L;
            RotateLeft(pNode);
            break;
        case L:
            pRight->balance = B;
            pNode->balance = B;
            RotateRight(pRight);
            RotateLeft(pNode);
            break;
        case R:
            pRight->balance = B;
            pNode->balance = B;
            RotateLeft(pNode);
            break;
        }
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    void CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::DeleteAux(LinkType& pNode, ConstReference value, bool& shorter)
    {
        if(pNode->pLeft == NULL && pNode->pRight == NULL)
        {
            if(LeftMost() == pNode)
                LeftMost() = pNode->pParent;
            if(RightMost() == pNode)
                RightMost() = pNode->pParent;

            DeleteNode(pNode);
            shorter = true;
            count_--;
        }
        else if(pNode->pLeft == NULL)
        {
            if(LeftMost() == pNode)
            {
                LinkType pRChild = pNode->pRight;
                while(pRChild->pLeft)
                    pRChild= pRChild->pLeft;
                LeftMost() = pRChild;
            }
            pNode->pRight->pParent = pNode->pParent;
            LinkType pTemp = pNode->pRight;
            DeleteNode(pNode);
            pNode = pTemp;

            shorter = true;
            count_--;
        }
        else if(pNode->pRight == NULL)
        {
            if(RightMost() == pNode)
            {
                LinkType pLChild = pNode->pLeft;
                while(pLChild->pRight)
                    pLChild= pLChild->pRight;
                RightMost() = pLChild;
            }
            pNode->pLeft->pParent = pNode->pParent;
            LinkType pTemp = pNode->pLeft;
            DeleteNode(pNode);
            pNode = pTemp;

            shorter = true;
            count_--;
        }
        else
        {
            LinkType pNodeTemp = pNode; //store pNode locate, coz after delete operation, pNode maybe changed.(pNode is ref)
            LinkType pLChild = pNode->pLeft;
            while(pLChild->pRight)
                pLChild= pLChild->pRight;
            ValueType temp = pLChild->value;
            Delete(pLChild->value);
            pNodeTemp->value = temp;
            shorter = false;
        }
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    int CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::InnerDelete(LinkType& pNode, ConstReference value, bool& shorter)
    {
        if(pNode == NULL)
            return 0;

        if(compare_(keyOfValue_(pNode->value), keyOfValue_(value)))
        {
            if(!InnerDelete(pNode->pRight, value, shorter))
                return 0;

            if(shorter)
            {
                switch(pNode->balance)
                {
                case B:
                    pNode->balance = L;
                    shorter = false;
                    break;
                case L:
                    DelLeftAdjust(pNode);
                    shorter = true;
                    break;
                case R:
                    pNode->balance = B;
                    shorter = true;
                    break;
                }
            }
        }
        else if(compare_(keyOfValue_(value), keyOfValue_(pNode->value)))
        {
            if(!InnerDelete(pNode->pLeft, value, shorter))
                return 0;

            if(shorter)
            {
                switch(pNode->balance)
                {
                case B:
                    pNode->balance = R;
                    shorter = false;
                    break;
                case L:
                    pNode->balance = B;
                    shorter = true;
                    break;
                case R:
                    DelRightAdjust(pNode);
                    shorter = true;
                    break;
                }
            }

        }
        else
        {
            DeleteAux(pNode, value, shorter);
        }
        return 1;
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    int CAVLTree<Key, Value, KeyOfValue, Compare, Alloc>::Delete(ConstReference value)
    {
        if(Root() == NULL)
            return 0;

        bool shorter = false;
        return InnerDelete(Root(), value, shorter);
    }

}
#endif

 

#ifndef _ALLOC_H_
#define _ALLOC_H_
#pragma once

#include <new>

#ifndef NULL
#define NULL 0
#endif

namespace KOK
{
    class __CSimpleAlloc
    {
    public:
        static void* Allocate(size_t n)
        {
            if(n != NULL) return ::operator new(n);
        }

        static void Deallocate(void* p)
        {
            if(p != NULL) return ::operator delete(p);
        }
    };

    template <class T, class Value>
    inline void Construct(T* p, Value& value)
    {
        new(p) T(value);
    }

    template <class T, class Value>
    inline void Construct(T* p)
    {
        new(p) T();
    }

    template <class T>
    inline void Destroy(T* p)
    {
        p->~T();
    }

#ifndef _USE_CUSTOM_ALLOC_
    typedef __CSimpleAlloc alloc;
#endif

    template <class T, class Alloc = alloc>
    class CAllocAdapter
    {
    public:
        static T* Allocate(size_t n)
        {
            return n == 0 ? 0 : (T*)Alloc::Allocate(n * sizeof(T));
        }

        static T* Allocate(void)
        {
            return (T*)Alloc::Allocate(sizeof(T));
        }

        static void Deallocate(T* p)
        {
            Alloc::Deallocate(p);
        }

        static void Deallocate(T* p, size_t n)
        {
            Alloc::Deallocate(p);
        }

    };
}
#endif

 

#ifndef _KOK_UTILITY_H_
#define _KOK_UTILITY_H_
#pragma once

namespace KOK
{
    template<class T1, class T2> struct Pair
 { 
 typedef Pair<T1, T2> Self;
 typedef T1 FirstType;
 typedef T2 SecondType;

    Pair(const FirstType& _first, const SecondType& _second) : first(_first), second(_second) {}

 FirstType first; 
 SecondType second;
 };

}

#endif

daeees
关注
专栏目录
AVL Tree 平衡二叉树
05-23 1096
使用例子： #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <iostream.h> #include "AVLTree.h" using namespace std; class CCity { public: CCity(const char...
AVL树（平衡二叉树（Balanced Binary Tree））
lfdanding的专栏
06-08 1210
转载地址是  http://noalgo.info/661.html AVL树是一种自平衡的二叉查找树（Balanced Binary Tree），由于其任意节点的左右子树的高度差至多为一，查找、插入、删除等操作的复杂度在平均和最坏情况下都是O（log n）。AVL树和红黑树都是平衡的二叉查找树，但二者有一些细微的区别，本文将详细讲解AVL树的原理与实现，并且部分实现过程参照了红黑树，具体可
某高人实现的红黑树模板类
小豪之家
12-26 2279
某高人实现的红黑树模板类
平衡二叉树（Balance Binary Tree） --AVL树
tanjiquan的博客
02-18 6885
平衡二叉树（Balance Binary Tree）又称AVL树。对二叉查找树做了很大的改进，使得查找的效率真正保证为O（logN），每次插入都保证树必须满足平衡。
04-树5 Root of AVL Tree
叶柖的博客
05-07 293
An AVL tree is a self-balancing binary search tree. In an AVL tree, the heights of the two child subtrees of any node differ by at most one; if at any time they differ by more than one, rebalancing is...
C++ STL（第十二篇：容器--关联式容器介绍和树的导览）
weixin_39640298的博客
04-13 1108
1、关联式容器 前面刚开始整理 STL 容器 时，简单的说了一下容器可以分为两类 序列式容器 和 关联式容器。前面又对主要的 序列式容器 进行了整理，今天终于轮到 关联式容器了。 所谓关联式容器，观念上类似关联式数据库：每笔数据都有一个键值（key）和一个实值（value）。当元素插入到关联式容器中时，容器内部结构便依照其键值大小，以某种特定规则将这个元素放置于适当位置。关联式容器没有所谓头尾（只...
图解AVL树
日积月累，天道酬勤
06-18 1065
引言 AVL树是带有平衡条件的二叉查找树，它保证树的深度须是O(logN)O(logN)O(logN)。 特性：它每个节点的左子树和右子树的高度最多差1。 空树的高度定义为-1。 上图中左边的树是AVL树，而右边不是。右边树左子树高度为3，右子树高度为1，相差超过1。 实现 树节点结构 private static class Node<E> { E data; No...
007.Binary Tree
dosdiosas_的博客
04-14 218
      本文给出基于C++完成的二叉树模板类以及它的测试主函数，主要具有二叉树的四种遍历算法的递归与非递归实现，同样，为了不重复造轮子，BinTree模板类给出了可以用来继承的多种接口，用来对日后实现红黑树，AVL，Trie树等数据结构的实现起到辅助作用，代码中大量使用宏，使得在主要的算法里面对函数的复杂调用得以简化，并且在实际执行的...
小张学linux内核之数据结构：2. rbtree
qq_40036519的博客
06-17 384
rbtree作为平衡二叉树在linux内核中的使用很广泛，如前文讲到的cfs调度类组织调度实体se，以及内存子系统中用来管理内存。
leetcode答案-myDataStructure:我的数据结构
06-30
BinaryTree遍历(用map实作) BST(实作insert, predecessor, successor) Augmented_BST(扩充的BST，实作exists(判断key是否存在), insert, predecessor, successor, rank(给key求排名), select(给排名求key)) AVL tree...
查找——平衡二叉树Balanced Binary/Height-Balanced Tree的详解与实现
lseaJK的博客
06-29 1109
查找8.5 平衡二叉树8.5.1 平衡二叉树的定义8.5.2 平衡旋转8.5.3 插入结点8.5.4 删除结点其他 8.5 平衡二叉树 在二叉排序树上实现查找的时间复杂度与从根到所查数据元素的结点的路径长度成正比，在最坏情况下这个长度等于树的高度。在构造二叉排序树时，如果输入的数据元素序列恰巧按其关键字大小有序，则在形式上已经退化成一个单链表了。这样查找操作所需要的时间就是O(n),或者说与结点个数成线性关系。 因此需要有一种方法来避免使二叉排序树变得过于窄而高这种情况的发生。如果能够保证树的高度与树中结点
平衡二叉排序树、AVL树、红黑树、B树、B+树
qq_37997523的博客
03-08 758
1、平衡二叉排序树 　 二叉查找树定义：又称为是二叉排序树（Binary Sort Tree）或二叉搜索树。二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： 　　1) 若左子树不空，则左子树上所有结点的值均小于它的根结点的值； 　　2) 若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值； 　　3) 左、右子树也分别为二叉排序树； 　　4) 没有键值相等的节点。 ...
数据结构与算法基础知识 (Python 语言)
最新发布
AI天才研究院
06-26 4558
是指把数据类型和数据类型上的运算封装在一起。最常用的数据运算：插入、删除、修改、查找、排序。
BOOST源码笔记(2) - boost::thread之内部干将interrupt_wait
daeees的专栏
06-10 8396
    BOOST的Thread库博大精深，有很多的多线程概念在里面，今天就对其中很多call都用到的interrupt_wait的实现进行解释。首先，在BOOST文档中，有1个不得不看的概念，如下：Predefined Interruption Points The following functions are interruption points, which will throw
BOOST源码笔记(1) - boost::call_once
daeees的专栏
06-08 5075
boost::call_once应用及其实现 以下是一个典型的运用call_once实现一次初始化的例子：Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1 #include boost/thread/thread.h
BOOST源码笔记(5) - 最小的代价实现同步-无锁编程，看boost中的interlocked_bit_test_and_set实现
daeees的专栏
06-12 4118
如题，如何用最小的代价来实现同步呢，即无锁编程（主要是使用原子操作替代锁来实现对共享资源的访问保护）,我们来看看下面的代码。首先，我们需要是在这个函数内部对地址x中的值进行位测试并将其对应的位置位。  这里的关键是我们必须先读出*x的值，作位或运算之后，将得到的值对*x赋值。而在多线程环境中，在读出*x后也许有另外的线程对*x进行写操作，这样在给*x赋值的时候就会把对旧的值位或的结果赋给*
BOOST源码笔记(3) - 节省内存的小技巧
daeees的专栏
06-11 1381
 先不多说，来看段代码： struct state_data        {            unsigned shared_count:11,                shared_waiting:11,                exclusive:1,                upgrade:1,                exclusive_wait
Tip: 如何保证一个类只能在堆上被创建
daeees的专栏
07-18 995
<br />有的时候为了保证一个类的对象必须在堆上被创建, 比如当我们需要手动控制一个对象的生命周期的时候, 这个时候就必须保证这个对象是在堆上创建的, 如何保证呢, 有个小的技巧:<br /> <br />class A <br />{<br />public:<br />    void Close() {delete this; }<br />private:<br />    ~A() { ... };<br />};<br /> <br />int main()<br />{<br />    A
Google C++ Convention
daeees的专栏
03-11 931
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#The__define_GuardGist: 头文件：#define: ___H_. #include: 当forward declaration(for example: class A;) 够用时别再用#include了 在没有类定义的情况下(For example, only declare class Foo), 依然可用的有： 数据成员是Foo* or Foo&函数的参
avl tree insertion
04-06
AVL树插入是指在AVL树中添加新元素的过程。在插入元素后，AVL树需要进行平衡操作，以保证树的高度平衡，即左右子树的高度差不超过1。平衡操作有四种：左旋、右旋、左右旋和右左旋。通过这些操作，AVL树可以自我调整...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值