RBTree实作

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

#ifndef _KOK_RBTREE_H_
#define _KOK_RBTREE_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 CRBTree
    {
        enum __Color { R = 0, B = 1 };

        template <class NodeValue>
        struct CRBTreeNode
        {
            typedef CRBTreeNode<NodeValue>* LinkType;
            LinkType pParent;
            LinkType pLeft;
            LinkType pRight;
            __Color color;
            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 CRBTreeIterator
        {
            typedef V ValueType;
            typedef R Reference;
            typedef P Pointer;
            typedef CRBTreeNode<ValueType>* LinkType;
            typedef CRBTreeIterator<ValueType, Reference, Pointer> Self;
            typedef CRBTreeIterator<Value, Value&, Value*> Iterator;
            typedef CRBTreeIterator<Value, const Value&, const Value*> ConstIterator;

        private:
            LinkType pNode_;

        private:
            void Increment()
            {
                if(pNode_->pParent->pParent == pNode_ && pNode_->color == __Color::R)
                    return;
                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_->pParent->pParent == pNode_ && pNode_->color == __Color::R)
                    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:
            CRBTreeIterator(const LinkType& pNode)
            {
                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 CRBTreeNode<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 CRBTreeIterator<ValueType, Reference, Pointer> Iterator;

    protected:
        typedef CRBTreeNode<Value>* LinkType;

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

    protected:
        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->color = __Color::R;
            Construct(&pNode->value, value);
            return pNode;
        }
        LinkType GetNode() { return NodeAlloc::Allocate();}
        void PutNode(LinkType pNode) { NodeAlloc::Deallocate(pNode); }

        void Init()
        {
            pHeader_ = GetNode();
            pHeader_->color = __Color::R;
            pHeader_->pLeft = pHeader_->pRight = pHeader_;
            pHeader_->pParent = NULL;
            count_ = 0;
        }

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

        void RotateLeft(LinkType pNode, LinkType& pRoot);
        void RotateRight(LinkType pNode, LinkType& pRoot);
        void BalanceAdjust(LinkType pNewNode, LinkType& pRoot);
        Iterator InsertAux(LinkType pParent, LinkType& pRoot, ConstReference value);
        bool DeleteAux(LinkType pNode, LinkType pParent, ConstReference value);
        void DeleteAdjust(LinkType pNode, LinkType pParent, LinkType& pRoot);
        void ClearAux(LinkType& pNode);
    public:
        CRBTree();
        ~CRBTree();

        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;}

        Pair<Iterator, bool> InsertUnique(ConstReference value);
        Iterator InsertEqual(ConstReference value);
        int Delete(ConstReference value);

        void Clear();
        Iterator Find(const KeyType& key);
       
    private:
        CRBTree& operator =(const CRBTree&);
        CRBTree(const CRBTree&);
    };

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    void CRBTree<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 CRBTree<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>
    CRBTree<Key, Value, KeyOfValue, Compare, Alloc>::~CRBTree()
    {
        Clear();
        PutNode(pHeader_);
    }

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

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    typename CRBTree<Key, Value, KeyOfValue, Compare, Alloc>::Iterator CRBTree<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>
    void CRBTree<Key, Value, KeyOfValue, Compare, Alloc>::RotateLeft(LinkType pNode, LinkType& pRoot)
    {
        LinkType pRight = pNode->pRight;
        pNode->pRight = pRight->pLeft;
        if(pRight->pLeft)
            pRight->pLeft->pParent = pNode;
        pRight->pParent = pNode->pParent;

        if(pRoot == pNode)
            pRoot = pRight;
        else if(pNode == pNode->pParent->pRight)
            pNode->pParent->pRight = pRight;
        else
            pNode->pParent->pLeft = pRight;

        pRight->pLeft = pNode;
        pNode->pParent = pRight;
    }

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

        if(pRoot == pNode)
            pRoot = pLeft;
        else if(pNode == pNode->pParent->pRight)
            pNode->pParent->pRight = pLeft;
        else
            pNode->pParent->pLeft = pLeft;

        pLeft->pRight = pNode;
        pNode->pParent = pLeft;
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    void CRBTree<Key, Value, KeyOfValue, Compare, Alloc>::BalanceAdjust(LinkType pNewNode, LinkType& pRoot)
    {
        pNewNode->color = __Color::R;
        while(pNewNode != pRoot && pNewNode->pParent->color == __Color::R)
        {
            if(pNewNode == pNewNode->pParent->pLeft)
            {
                LinkType pSParent = pNewNode->pParent->pParent->pRight;
                if(pSParent && pSParent->color == __Color::R)
                {
                    pNewNode->pParent->pParent->color = __Color::R;
                    pNewNode->pParent->color = __Color::B;
                    pSParent->color = __Color::B;
                    pNewNode = pNewNode->pParent->pParent;
                }
                else
                {
                    if(pNewNode->pParent->pRight == pNewNode)
                    {
                        RotateLeft(pNewNode->pParent, pRoot);
                        pNewNode = pNewNode->pLeft;
                    }
                    pNewNode->pParent->color = __Color::B;
                    pNewNode->pParent->pParent->color = __Color::R;
                    RotateRight(pNewNode->pParent->pParent, pRoot);
                }
            }
            else
            {
                LinkType pSParent = pNewNode->pParent->pParent->pLeft;
                if(pSParent && pSParent->color == __Color::R)
                {
                    pNewNode->pParent->pParent->color = __Color::R;
                    pNewNode->pParent->color = __Color::B;
                    pSParent->color = __Color::B;
                    pNewNode = pNewNode->pParent->pParent;
                }
                else
                {
                    if(pNewNode->pParent->pLeft == pNewNode)
                    {
                        RotateRight(pNewNode->pParent, pRoot);
                        pNewNode = pNewNode->pRight;
                    }
                    pNewNode->pParent->color = __Color::B;
                    pNewNode->pParent->pParent->color = __Color::R;
                    RotateLeft(pNewNode->pParent->pParent, pRoot);
                }
            }
        }

        pRoot->color = __Color::B;
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    typename CRBTree<Key, Value, KeyOfValue, Compare, Alloc>::Iterator CRBTree<Key, Value, KeyOfValue, Compare, Alloc>::InsertAux(LinkType pParent, LinkType& pRoot, ConstReference value)
    {
        LinkType pNewNode;
        if(pParent == pHeader_ || compare_(keyOfValue_(value), keyOfValue_(pParent->value)))
        {
            pNewNode = CreateNode(value);
            Left(pParent) = pNewNode;

            if(pParent == pHeader_)
            {
                Root() = pNewNode;
                Right(pParent) = pNewNode;
            }
            else if(pParent == LeftMost())
            {
                LeftMost() = pNewNode;
            }
        }
        else
        {
            pNewNode = CreateNode(value);
            Right(pParent) = pNewNode;
            if(pParent == RightMost())
                RightMost() = pNewNode;
        }

        Parent(pNewNode) = pParent;

        BalanceAdjust(pNewNode, Root());
        count_++;
        return Iterator(pNewNode);
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    Pair<typename CRBTree<Key, Value, KeyOfValue, Compare, Alloc>::Iterator, bool> CRBTree<Key, Value, KeyOfValue, Compare, Alloc>::InsertUnique(ConstReference value)
    {
        LinkType pParent = pHeader_;
        LinkType pNode = Root();
        bool comp = true;

        while(pNode != NULL)
        {
            pParent = pNode;
            comp = compare_(keyOfValue_(value), keyOfValue_(pNode->value));
            pNode = comp ? Left(pNode) : Right(pNode);
        }

        Iterator iter = Iterator(pParent);
        if(comp)
            if(iter == Begin())
               return Pair<Iterator, bool>(InsertAux(pParent, Root(), value), true);
            else
                iter--;
        if(compare_(keyOfValue_(*iter), value))
            return Pair<Iterator, bool>(InsertAux(pParent, Root(), value), true);

        return Pair<Iterator, bool>(iter, false);
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    typename CRBTree<Key, Value, KeyOfValue, Compare, Alloc>::Iterator CRBTree<Key, Value, KeyOfValue, Compare, Alloc>::InsertEqual(ConstReference value)
    {
        LinkType pParent = pHeader_;
        LinkType pNode = Root();
        while(pNode != NULL)
        {
            pParent = pNode;
            pNode = compare_(keyOfValue_(value), keyOfValue_(pNode->value)) ? Left(pNode) : Right(pNode);
        }

        return InsertAux(pParent, Root(), value);
    }


    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    void CRBTree<Key, Value, KeyOfValue, Compare, Alloc>::DeleteAdjust(LinkType pNode, LinkType pParent, LinkType& pRoot)
    {
        if(pNode == pParent->pLeft) //both of pParent's child node can not be NULL
        {
            Node node;
            LinkType pSNode; // pSNode can not be NULL due to the rule of RBTree

            if(pNode == NULL)
            {
                pNode = &node;
                pNode->color = __Color::B;
                Parent(pNode) = pParent;
            }
            else if(pNode->color == __Color::R)
            {
                pNode->color = __Color::B;
                return;
            }

            while(pNode != pRoot && pNode->color == __Color::B)
            {
                pSNode = Right(Parent(pNode));
                if(pSNode->color == __Color::R)
                {
                    pSNode->color = Parent(pNode)->color;
                    Parent(pNode)->color = __Color::R;
                    RotateLeft(Parent(pNode), pRoot);
                }
                else if((!Right(pSNode) || Right(pSNode)->color == __Color::B) && (!Left(pSNode) || Left(pSNode)->color == __Color::B))
                {
                    pSNode->color = __Color::R;
                    pNode = pNode->pParent;
                }
                else if((Left(pSNode) && Left(pSNode)->color == __Color::R) && (!Right(pSNode) || Right(pSNode)->color == __Color::B))
                {
                    pSNode->color == __Color::R;
                    Left(pSNode)->color == __Color::B;
                    RotateRight(pSNode, pRoot);
                }
                else if(Right(pSNode) || Right(pSNode)->color == __Color::R)
                {
                    pSNode->color = Parent(pNode)->color;
                    Parent(pNode)->color = __Color::B;
                    RotateLeft(Parent(pNode), pRoot);
                    pNode = Right(pSNode);
                }
            }

            pNode->color = __Color::B;
        }
        else if(pNode == pParent->pRight)
        {
            Node node;
            LinkType pSNode; // pSNode can not be NULL due to the rule of RBTree

            if(pNode == NULL)
            {
                pNode = &node;
                pNode->color = __Color::B;
                Parent(pNode) = pParent;
            }
            else if(pNode->color == __Color::R) // case 1: must in the front of all the cases.
            {
                pNode->color = __Color::B;
                return;
            }

            while(pNode != pRoot && pNode->color == __Color::B)
            {
                pSNode = Left(Parent(pNode));
                if(pSNode->color == __Color::R) //case 2:
                {
                    pSNode->color = Parent(pNode)->color;
                    Parent(pNode)->color = __Color::R;
                    RotateRight(Parent(pNode), pRoot);
                }
                else if((!Right(pSNode) || Right(pSNode)->color == __Color::B) && (!Left(pSNode) || Left(pSNode)->color == __Color::B)) // case 3:
                {
                    pSNode->color = __Color::R;
                    pNode = pNode->pParent;
                }
                else if((Right(pSNode) && Right(pSNode)->color == __Color::R) && (!Left(pSNode) || Left(pSNode)->color == __Color::B)) //case 4:
                {
                    pSNode->color == __Color::R;
                    Right(pSNode)->color == __Color::B;
                    RotateLeft(pSNode, pRoot);
                }
                else if(Left(pSNode) || Left(pSNode)->color == __Color::R) //case 5:
                {
                    pSNode->color = Parent(pNode)->color;
                    Parent(pNode)->color = __Color::B;
                    RotateRight(Parent(pNode), pRoot);
                    pNode = Left(pSNode);
                }
            }

            pNode->color = __Color::B;
        }
        else //when delete root node
            return;
    }

    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    bool CRBTree<Key, Value, KeyOfValue, Compare, Alloc>::DeleteAux(LinkType pNode, LinkType pParent, ConstReference value)
    {
        if(pNode->pLeft == NULL && pNode->pRight == NULL)
        {
            __Color colTemp = pNode->color;

            if(LeftMost() == pNode)
                LeftMost() = pNode->pParent;
            if(RightMost() == pNode)
                RightMost() = pNode->pParent;
           
            if(pParent == pHeader_)
                pParent->pParent = NULL;

            if(pNode == pParent->pLeft)
                pParent->pLeft = NULL;
            else if(pNode == pParent->pRight)
                pParent->pRight = NULL;

            DeleteNode(pNode);
            if(colTemp != __Color::R) // dont need to fixup while the color of node deled is red.
                DeleteAdjust(NULL, pParent, Root());
            count_--;
        }
        else if(pNode->pLeft == NULL) //only condition: parent->color = black; rchild->color = red;
        {
            if(LeftMost() == pNode)
            {
                LinkType pRChild = pNode->pRight;
                while(pRChild->pLeft)
                    pRChild= pRChild->pLeft;
                LeftMost() = pRChild;
            }

            pNode->pRight->pParent = pNode->pParent;
            LinkType pTemp = pNode->pRight;

            if(pParent == pHeader_)
                pParent->pParent = pTemp;

            if(pNode == pParent->pLeft)
                pParent->pLeft = pTemp;
            else if(pNode == pParent->pRight)
                pParent->pRight = pTemp;

            DeleteNode(pNode);
            DeleteAdjust(pTemp, pParent, Root());
            count_--;
        }
        else if(pNode->pRight == NULL) //only condition: parent->color = black; lchild->color = red;
        {
            if(RightMost() == pNode)
            {
                LinkType pLChild = pNode->pLeft;
                while(pLChild->pRight)
                    pLChild= pLChild->pRight;
                RightMost() = pLChild;
            }
            pNode->pLeft->pParent = pNode->pParent;
            LinkType pTemp = pNode->pLeft;

            if(pParent == pHeader_)
                pParent->pParent = pTemp;

            if(pNode == pParent->pLeft)
                pParent->pLeft = pTemp;
            else if(pNode == pParent->pRight)
                pParent->pRight = pTemp;

            DeleteNode(pNode);
            DeleteAdjust(pTemp, pParent, Root());
            count_--;
        }
        else // dont need to fixup again, Delete() method has already done it.
        {
            LinkType pLChild = pNode->pLeft;
            while(pLChild->pRight)
                pLChild= pLChild->pRight;
            ValueType temp = pLChild->value;
            Delete(pLChild->value);
            pNode->value = temp;
            return true;
        }

        return false;
    }
   
    template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    int CRBTree<Key, Value, KeyOfValue, Compare, Alloc>::Delete(ConstReference value)
    {
        LinkType pParent = pHeader_;
        LinkType pNode = Root();

        while(pNode != NULL)
        {
            if(compare_(keyOfValue_(value), keyOfValue_(pNode->value)))
            {
                pParent = pNode;
                pNode = Left(pNode);
            }
            else if(compare_(keyOfValue_(pNode->value), keyOfValue_(value)))
            {
                pParent = pNode;
                pNode = Right(pNode);
            }
            else
                break;
        }

        if(pNode == NULL)
            return 0;
       
        DeleteAux(pNode, pParent, value);
        return 1;
    }
   
}

#endif

daeees
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
海量数据处理面试题与Bit-map详解
wenyusuran的专栏
07-07 2441
同时，程序员编程艺术系列将重新开始创作，第十一章以后的部分题目来源将取自下文中的17道海量数据处理的面试题。因为，我们觉得，下文的每一道面试题都值得重新思考，重新深究与学习。再者，编程艺术系列的前十章也是这么来的。若您有任何问题或建议，欢迎不吝指正。谢谢。 第一部分、十五道海量数据处理面试题 1. 给定a、b两个文件，各存放50亿个url，每个url各占64字节，内存限制是4G，让你找出a、b
rbtree
weixin_30457551的博客
12-08 61
。。 转载于:https://www.cnblogs.com/budapeng/p/6144668.html
小张学linux内核之数据结构：2. rbtree
qq_40036519的博客
06-17 342
rbtree作为平衡二叉树在linux内核中的使用很广泛，如前文讲到的cfs调度类组织调度实体se，以及内存子系统中用来管理内存。
LINUX系统CFS调度模型实现思考和仿真
最新发布
tugouxp的专栏
04-05 983
采用绝对优先级没有记忆性，过去的运行记录不会影响当前时刻的调度决策，所以高优先级的线程有绝对优先权。而CFS调度器是有记忆性的，过去的运行记录会体现在线程整体的运行进度中，从而影响当前的调度决策。
Linux进程调度器的设计--Linux进程的管理与调度(十七）
OSKernelLAB(gatieme)
06-17 2万+
日期 内核版本 架构 作者 GitHub CSDN 2016-06-14 Linux-4.6 X86 & arm gatieme LinuxDeviceDrivers Linux进程管理与调度 1 前景回顾1.1 进程调度内存中保存了对每个进程的唯一描述, 并通过若干结构与其他进程连接起来.调度器面对的情形就是这样, 其任务是在程序之间共享CPU时间,
Linux学习路线
OSKernelLAB(gatieme)
04-09 1万+
自己的学习路线写一下最近个人的linux学习路线，学完后再好好参考其他人的：1.《Linux程序设计》- 靠它来入门，然后装一个linux系统，学习shell(bash)和linux C，把基础打牢； 2. 《深入理解Linux内核》和《Linux内核设计与实现》：后者我已经粗粗看过一遍，值得细看，前者必须尽快看完； 3. 《Linux设备驱动设计》：必买必看，实用性强； 4.《Advance
教你如何迅速秒杀掉：99%的海量数据处理面试题
幸福在路上
08-18 2153
原文：http://blog.csdn.net/v_july_v/article/details/7382693 教你如何迅速秒杀掉：99%的海量数据处理面试题 作者：July 出处：结构之法算法之道blog 前言    一般而言，标题含有“秒杀”，“99%”，“史上最全/最强”等词汇的往往都脱不了哗众取宠之嫌，但进一步
程序员编程艺术：第三章续、Top K算法问题的实现
热门推荐
结构之法 算法之道
05-08 8万+
程序员编程艺术：第三章续、Top K算法问题的实现    作者：July，zhouzhenren，yansha。    致谢：微软100题实现组，狂想曲创作组。    时间：2011年05月08日    微博：http://weibo.com/julyweibo 。    出处：http://blog.csdn.net/v_JULY_v 。    wiki：http://tctop.wikispa
Linux内核API手册——简略版
CrazyHeroZK的专栏
02-15 9041
Kernel API 寻址 页表与页 TLB NODE、CPU与寄存器 寄存器操作 CPU特性 PerCPU变量操作 CPU位掩码 NODE操作 内核同步 内核抢占 原子操作 位锁 内存屏障 自旋锁 位图操作 顺序锁 信号量 PerCPU 读写信号量 完成变量 中断操作 工作队列 等待队列 内存管理 物理页管理 非整页内存管理 非连续内存管理 时间管理 节拍软定时器...
红黑树rbTree.c
05-12
红黑树的遍历，查找过程，以及插入时对红黑树进行位置修复，修复包括左旋右旋，还有就是红黑树节点的删除，删除之后还要对节点修复
RBTree-Program.rar_RBtree
09-19
红黑树（Red-Black Tree，简称RBTree）是一种自平衡二叉查找树，由Rudolf Bayer在1972年提出。这种数据结构在现代计算机科学中有着广泛的应用，尤其是在操作系统、数据库系统和各种编程语言的标准库中。红黑树的名字...
rbtree_ubuntu_kenerl5.2.2.rar
07-28
`rbtree.c`和`rbtree.h`包含了Linux内核中红黑树的实现代码和头文件。`rbtree.txt`可能是对红黑树实现的文档说明或者详细注解。 在`rbtree.c`中，你可以期待看到以下关键函数和数据结构： - `rb_node`：表示红黑树...
rbtree2.zip
06-13
在Linux系统中，红黑树（Red-Black Tree，简称RBTree）是一种自平衡二叉查找树，它具有良好的性能特性，被广泛应用于各种数据结构和算法实现中，如内核中的内存管理、文件系统等。红黑树的名字来源于其节点颜色属性...
使用C语言实现的rbtree红黑树.zip
03-21
红黑树（Red-Black Tree）是一种自平衡的二叉查找树，由计算机科学家Rudolf Bayer在1972年提出。它在保持二叉查找树特性的同时，通过引入颜色属性来确保树的平衡，从而提高数据操作的效率。在C语言中实现红黑树，...
BOOST源码笔记(2) - boost::thread之内部干将interrupt_wait
daeees的专栏
06-10 8366
    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 5056
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 4095
如题，如何用最小的代价来实现同步呢，即无锁编程（主要是使用原子操作替代锁来实现对共享资源的访问保护）,我们来看看下面的代码。首先，我们需要是在这个函数内部对地址x中的值进行位测试并将其对应的位置位。  这里的关键是我们必须先读出*x的值，作位或运算之后，将得到的值对*x赋值。而在多线程环境中，在读出*x后也许有另外的线程对*x进行写操作，这样在给*x赋值的时候就会把对旧的值位或的结果赋给*
BOOST源码笔记(3) - 节省内存的小技巧
daeees的专栏
06-11 1370
 先不多说，来看段代码： struct state_data        {            unsigned shared_count:11,                shared_waiting:11,                exclusive:1,                upgrade:1,                exclusive_wait
btree rbtree
10-16
B树和红黑树是两种常用的平衡搜索树数据结构。 B树，也称为B-树，是一种多叉树。它的特点是所有关键字按顺序存储在树中，并且每个节点可以存储多个关键字和对应的值。B树通过一些特定的规则来保持树的平衡，使得...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值