红黑树hashmap-RbtHashMap实现

已于 2022-05-22 13:42:49 修改
阅读量447 收藏 1
点赞数 2
分类专栏： c/c++ 文章标签： 散列表 哈希算法 c++ 算法 数据结构
于 2022-05-22 13:39:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/D_Guco/article/details/124908719
版权

      在之前的文章（自定义固定长度map）中实现过一个固定长度的map，其目的主要是为了实现固定长度在插入和删除过程中避免new和delete的内存调用，重复利用内存，但是它有一个很明显的缺陷，就是因为是固定长度冲突率会比标准库的map高，当冲突率高到一定长度时，其查找和删除效率会直线下降，所以为了进一步优化它的实现，就把发生冲突的元素由链表维护改为红黑树维护，这样最坏的情况下所有的元素的key的hash值都一样也只是退化为std::map而不是一个链表，因此带来此种情况下插入和删除性能的极大的提升。

      

std::unordered_map和之前的实现方式hash+单链表

新的实现方式hash+RBTree

     通过对比可以很直观的看到，当最坏的情况下所有的元素都为同一个hash值的时候，两者的区别一个退化为链表而新的实现则为一棵红黑树，查找效率有着天壤之别。

完整源码实现链接：

gitee地址https://gitee.com/DGuco/dsalgorithm/tree/master/rbtarr_mapgithub地址https://github.com/DGuco/DSAlgorithm/tree/master/rbtarr_map

测试用例：

//
// Created by DGuco on 2022/4/13.
// email:1139140929@qq.com
//
#include <iostream>
#include <list>
#include <unordered_map>
#include <pthread.h>
#include <sys/time.h>
#include <unistd.h>
#include <mutex>

#include "rbthash_map.h"
#include "rb_tree.h"


using namespace rbt_hash;
using namespace std;
#define TEST_COUNT 1000000
#define REMOVE_COUNT 50000
#define RB_COUNT 5000
#define HASH_CONFLICT_COUNT 5
#define HASH_CONFLICT_COUNT1 10000
#define COMSUME_KEEP_TIME 60 * 1000 * 1000
void testRBTree()
{
    printf("==========================test rbtree start===================================\n");
    // 设置种子
    srand( (unsigned)time( NULL ) );
    int *a= new int[RB_COUNT];
    RBTNode<int,unsigned int>* node = new RBTNode<int,unsigned int>[RB_COUNT];
    RBTree<int,int,unsigned int,RB_COUNT>tree(node,0);
    cout << "== 原始数据: ";
    int i = 0;
    std::unordered_map<int,int> stdmap;
    for(i=0; i < RB_COUNT; i++)
    {
        int key = rand();
        while (1)
        {
            if(stdmap.find(key) == stdmap.end())
            {
                break;
            }else
            {
                key = rand();
            }
        }
        a[i] = key;
        stdmap.insert(std::make_pair(key,1));
        cout << a[i] <<" ";
        node[i].init_rb();
        node[i].set_key(a[i]);
    }
    cout << endl;

    for(i=0; i<RB_COUNT; i++)
    {
        tree.insert(&node[i]);
        if(!tree.isRBTree())
        {
            tree.print();
            printf("test rbtree insert failed\n");
            exit(0);
        }
    }

    cout << "== 前序遍历: ";
    std::list<RBTNode<int,unsigned int>*> resList;
    resList.clear();
    tree.preOrder(resList);
    std::list<RBTNode<int,unsigned int>*>::iterator it = resList.begin();
    for(;it != resList.end();it++)
    {
        cout << (*it)->get_key() << " ";
    }
    cout << "\n== 中序遍历: ";
    resList.clear();
    tree.inOrder(resList);
    it = resList.begin();
    for(;it != resList.end();it++)
    {
        cout << (*it)->get_key() << " ";
    }
    cout << "\n== 后序遍历: ";
    resList.clear();
    tree.postOrder(resList);
    it = resList.begin();
    for(;it != resList.end();it++)
    {
        cout << (*it)->get_key() << " ";
    }
    cout << endl;
    cout << "== 最小值: " << tree.minimum()->get_key() << endl;
    cout << "== 最大值: " << tree.maximum()->get_key() << endl;
//    cout << "== 树的详细信息: " << endl;
//    tree.print();
    printf("== test rbtree insert done\n");

    for(i=0; i<RB_COUNT; i++)
    {
        tree.remove(a[i]);
//        cout << "== 删除节点: " << a[i] << endl;
//        cout << "== 树的详细信息: " << endl;
//        tree.print();
        if(!tree.isRBTree())
        {
            tree.print();
            printf("test rbtree remove failed\n");
            exit(0);
        }
    }
    printf("== test rbtree remove done\n");
    delete[] node;
    delete [] a;
    printf("==========================test rbtree done===================================\n");
}

class ValueType
{
public:
    ValueType(int value) : a(value)
    {

    }

    ~ValueType()
    {

    }

    int Key()
    {
        return  a;
    }

    bool IsValid()
    {
        return  a >= 0;
    }

    int a;
};

void testInsert()
{
    // 设置种子
    srand( (unsigned)time( NULL ) );
    printf("==========================test insert start===================================\n");
    RbtHashMap<int,ValueType,TEST_COUNT>* testMap = new RbtHashMap<int,ValueType,TEST_COUNT>();
    std::unordered_map<int,ValueType> stdmap;
    while(true)
    {
        int key = rand();
        if(stdmap.find(key) == stdmap.end())
        {
            stdmap.insert(std::make_pair(key,ValueType(key)));
            testMap->insert(key,key);
        }

        if(stdmap.size() >= TEST_COUNT)
        {
            break;
        }
    }

    if(stdmap.size() != testMap->size())
    {
        printf("test insert failed stdsize = %d,rbtsize = %d\n",stdmap.size(),testMap->size());
        exit(0);
    }

    RbtHashMap<int,ValueType,TEST_COUNT>::iterator it = testMap->begin();
    for(;it != testMap->end();it++)
    {
        std::unordered_map<int,ValueType>::iterator  stdit = stdmap.find(it->first);
        if(stdit == stdmap.end())
        {
            printf("test insert failed never insert key = %d\n",it->first);
            exit(0);
        }
        if(it->second->a != stdit->second.a)
        {
            printf("test insert failed stdvalue= %d,rbtvalue = %d\n",stdit->second.a,it->second->a);
            exit(0);
        }
        //printf("it->first = %d,it->second = %d\n",it->first,it->second->a);
        stdmap.erase(it->first);
    }
    if(stdmap.size() > 0)
    {
        printf("test insert failed look map not all,last =  %d\n",stdmap.size());
        exit(0);
    }
    printf("==========================test insert done===================================\n");
    delete testMap;
    testMap = NULL;
}

void testremove()
{
    // 设置种子
    srand( (unsigned)time( NULL ) );
    printf("==========================test remove begin===================================\n");
    RbtHashMap<int,ValueType,TEST_COUNT>* testMap = new RbtHashMap<int,ValueType,TEST_COUNT>();
    std::unordered_map<int,ValueType> stdmap;
    while(true)
    {
        int key = rand();
        if(stdmap.find(key) == stdmap.end())
        {
            stdmap.insert(std::make_pair(key,ValueType(key)));
            testMap->insert(key,key);
        }

        if(stdmap.size() >= TEST_COUNT)
        {
            break;
        }
    }

    std::unordered_map<int,ValueType>::iterator stdit = stdmap.begin();
    int count = 0;
    for(;stdit != stdmap.end();)
    {
        if(!testMap->erase_check(stdit->first))
        {
            printf("test remove failed never remove key = %d\n",stdit->first);
            exit(0);
        }
        stdit = stdmap.erase(stdit);
        count++;
        if(count >= REMOVE_COUNT)
        {
            break;
        }
    }

    if(stdmap.size() != testMap->size())
    {
        printf("test remove failed stdsize = %d,rbtsize = %d\n",stdmap.size(),testMap->size());
        exit(0);
    }

    RbtHashMap<int,ValueType,TEST_COUNT>::iterator it = testMap->begin();
    count = 0;
    for(;it != testMap->end();it++)
    {
        count++;
        std::unordered_map<int,ValueType>::iterator  stdit = stdmap.find(it->first);
        if(stdit == stdmap.end())
        {
            printf("test remove failed never lost key = %d\n",it->first);
            exit(0);
        }
        if(it->second->a != stdit->second.a)
        {
            printf("test remove failed stdvalue= %d,rbtvalue = %d\n",stdit->second.a,it->second->a);
            exit(0);
        }
        stdmap.erase(it->first);
    }
    if(stdmap.size() > 0)
    {
        printf("test remove failed look map not all,last =  %d\n",stdmap.size());
        exit(0);
    }

    RbtHashMap<int,ValueType,TEST_COUNT>::iterator  beginit = testMap->begin();
    int erasecount = 0;
    int size = testMap->size();
    for(;beginit != testMap->end();)
    {
        beginit = testMap->erase(beginit);
        erasecount++;
    }
    if(erasecount != size || testMap->size() != 0)
    {
        printf("test remove failed size = %d,erasecount = %d\n",size,erasecount);
        exit(0);
    }
    printf("==========================test remove done===================================\n");
    delete testMap;
    testMap = NULL;
}

void testmempool()
{
    // 设置种子
    srand( (unsigned)time( NULL ) );
    printf("==========================test mempool begin===================================\n");
    RbtHashMap<int,ValueType,TEST_COUNT>* testMap = new RbtHashMap<int,ValueType,TEST_COUNT>();
    std::unordered_map<int,ValueType> stdmap;
    while(true)
    {
        int key = rand();
        if(stdmap.find(key) == stdmap.end())
        {
            stdmap.insert(std::make_pair(key,ValueType(key)));
            testMap->insert(key,key);
        }

        if(stdmap.size() >= TEST_COUNT)
        {
            break;
        }
    }

    std::unordered_map<int,ValueType>::iterator stdit = stdmap.begin();
    int count = 0;
    for(;stdit != stdmap.end();)
    {
        if(!testMap->erase_check(stdit->first))
        {
            printf("test mempool failed never remove key = %d\n",stdit->first);
            exit(0);
        }
        stdit = stdmap.erase(stdit);
        count++;
        if(count >= REMOVE_COUNT)
        {
            break;
        }
    }

    if(stdmap.size() != testMap->size())
    {
        printf("test mempool failed stdsize = %d,rbtsize = %d\n",stdmap.size(),testMap->size());
        exit(0);
    }

    while(true)
    {
        int key = rand();
        if(stdmap.find(key) == stdmap.end())
        {
            stdmap.insert(std::make_pair(key,ValueType(key)));
            if(!testMap->insert(key,key))
            {
                printf("test mempool failed some mem not reuse\n",stdmap.size(),testMap->size());
            }
        }

        if(stdmap.size() >= TEST_COUNT)
        {
            break;
        }
    }
    if(stdmap.size() != testMap->size())
    {
        printf("test mempool failed stdsize = %d,rbtsize = %d\n",stdmap.size(),testMap->size());
        exit(0);
    }

    printf("==========================test mempool done===================================\n");
    delete testMap;
    testMap = NULL;
}

// 获取当前微秒
time_t GetUSTime()
{
    struct timeval tmval = {0};
    int nRetCode = gettimeofday(&tmval, NULL);
    if (nRetCode != 0)
    {
        return 0;
    }
    return ((tmval.tv_sec * 1000 * 1000) + tmval.tv_usec);
}

void testformance()
{
    // 设置种子
    srand( (unsigned)time( NULL ) );
    time_t start = 0;
    time_t end = 0;
    unsigned long long res = 0;
    printf("---------------------------test performance begin---------------------------------------------\n");
    RbtHashMap<int,ValueType,TEST_COUNT>* testMap = new RbtHashMap<int,ValueType,TEST_COUNT>();
    start = GetUSTime();
    for(int i = 0;i < TEST_COUNT;i++)
    {
        testMap->insert(i * HASH_CONFLICT_COUNT, ValueType(i));
    }
    end = GetUSTime();
    printf("RbtHashMap<int,ValueType,%d>[conflict count = %d], insert use  %ld ms\n",TEST_COUNT,HASH_CONFLICT_COUNT,(end - start) / 1000);
    start = GetUSTime();
    res = 0;
    for(int i = 0;i < TEST_COUNT;i++)
    {
        res += testMap->find(i * HASH_CONFLICT_COUNT)->second->a;
    }
    end = GetUSTime();
    printf("RbtHashMap<int,ValueType,%d>[conflict count = %d] find use  %ld ms,res = %llu\n",TEST_COUNT,HASH_CONFLICT_COUNT,(end - start) / 1000,res);
    testMap->clear();
    start = GetUSTime();
    for(int i = 0;i < TEST_COUNT;i++)
    {
        testMap->insert(i * HASH_CONFLICT_COUNT1, ValueType(i));
    }
    end = GetUSTime();
    printf("RbtHashMap<int,ValueType,%d>[conflict count = %d], insert use  %ld ms\n",TEST_COUNT,HASH_CONFLICT_COUNT1,(end - start) / 1000);
    start = GetUSTime();
    res = 0;
    for(int i = 0;i < TEST_COUNT;i++)
    {
        res += testMap->find(i * HASH_CONFLICT_COUNT1)->second->a;
    }
    end = GetUSTime();
    printf("RbtHashMap<int,ValueType,%d>[conflict count = %d] find use  %ld ms,res = %llu\n",TEST_COUNT,HASH_CONFLICT_COUNT1,(end - start) / 1000,res);
    delete testMap;
    testMap = NULL;
    printf("------------------------------------------------------------------------\n");
    {
        std::map<int,ValueType> stdtMap;
        start = GetUSTime();
        for(int i = 0;i < TEST_COUNT;i++)
        {
            stdtMap.insert(std::make_pair(i * HASH_CONFLICT_COUNT, ValueType (i)));
        }
        end = GetUSTime();
        printf("std::map<int,ValueType> insert use  %ld ms\n",(end - start) / 1000);
        start = GetUSTime();
        res = 0;
        for(int i = 0;i < TEST_COUNT;i++)
        {
            res += stdtMap.find(i * HASH_CONFLICT_COUNT)->second.a;
        }
        end = GetUSTime();
        printf("std::map<int,ValueType> find use  %ld ms,res = %llu\n",(end - start) / 1000,res);
    }
    printf("------------------------------------------------------------------------\n");
    {
        std::unordered_map<int,ValueType> testUnorderMap;
        start = GetUSTime();
        for(int i = 0;i < TEST_COUNT;i++)
        {
            testUnorderMap.insert(std::make_pair(i * HASH_CONFLICT_COUNT, ValueType(i)));
        }
        end = GetUSTime();
        printf("std::unordered_map<int,ValueType> insert use  %ld ms\n",(end - start) / 1000);
        res = 0;
        start = GetUSTime();
        for(int i = 0;i < TEST_COUNT;i++)
        {
            res += testUnorderMap.find(i * HASH_CONFLICT_COUNT)->second.a;
        }
        end = GetUSTime();
        printf("std::unordered_map<int,ValueType> find use  %ld ms,res = %llu\n",(end - start) / 1000,res);
    }
    printf("-----------------------------test performance done-------------------------------------------\n");
    return;
}

RbtHashMap<int,ValueType,TEST_COUNT>* g_testMap = new RbtHashMap<int,ValueType,TEST_COUNT>();
std::unordered_map<int,ValueType> g_testUnorderMap;
std::mutex g_mtx;
bool g_exit = 0;
bool g_print1 = 0;
bool g_print2 = 0;
void* consume_insert(void* data)
{
    // 设置种子
    srand( (unsigned)time( NULL ) );
    unsigned int count = 0;
    while(true && !g_exit)
    {
        if(g_print1)
        {
            printf("consume inserting .....\n");
            g_print1 = 0;
        }
        {
            std::lock_guard<std::mutex> lck(g_mtx);
            if(g_testUnorderMap.size() >= TEST_COUNT)
            {
                continue;
            }else
            {
                int key = rand();
                if(g_testUnorderMap.find(key) == g_testUnorderMap.end())
                {
                    g_testUnorderMap.insert(std::make_pair(key,ValueType(key)));
                    if(!g_testMap->insert(key,key))
                    {
                        g_exit = 1;
                        printf("consume_insert insert failed testmap key = %d\n", key);
                        return 0;
                    }
                    count++;
                }
            }
        }
    }
    printf("consume_insert insert count = %d\n", count);
}

void* consume_remove(void* data)
{
    unsigned int count = 0;
    while (true && !g_exit)
    {
        if(g_print2)
        {
            printf("consume removing .....\n");
            g_print2 = 0;
        }
        {
            std::lock_guard<std::mutex> lck(g_mtx);
            std::unordered_map<int, ValueType>::iterator it = g_testUnorderMap.begin();
            if (it != g_testUnorderMap.end())
            {
                if (g_testMap->find(it->first) == g_testMap->end()) {
                    g_exit = 1;
                    printf("consume_remove find failed testmap lost key = %d\n", it->first);
                    return 0;
                }
                int key = it->first;
                g_testUnorderMap.erase(key);
                if (!g_testMap->erase_check(key))
                {
                    g_exit = 1;
                    printf("consume_remove erase failed testmap lost key = %d\n", key);
                    return 0;
                }
                count++;
            }
        }
    }
    printf("consume_insert remove count = %d\n", count);
}


void testconsume()
{
    printf("-----------------------------test consume begin-------------------------------------------\n");
    printf("test consume need time %d S,please waiting\n",COMSUME_KEEP_TIME / 1000 / 1000);
    pthread_t t1,t2;
    time_t start = GetUSTime();
    pthread_create(&t1,0,consume_insert,NULL);
    pthread_create(&t2,0,consume_remove,NULL);
    time_t lasttime = COMSUME_KEEP_TIME;
    time_t printstart = start;
    while (true)
    {
        time_t now = GetUSTime();
        if(now - printstart >= 20 * 1000 * 1000)
        {
            lasttime = lasttime - (now - printstart);
            printf("test consume last time %ld S,please waiting\n",lasttime / 1000 / 1000);
            g_print1 = 1;
            g_print2 = 1;
            printstart = now;
        }
        time_t keep = now - start;
        if(keep >= COMSUME_KEEP_TIME)
        {
            g_exit = 1;
            break;
        }
        usleep(10);
    }
    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
    printf("test consume keep time %d S\n",COMSUME_KEEP_TIME / 1000 / 1000);
    printf("-----------------------------test consume done-------------------------------------------\n");
}

int main()
{
    testRBTree();
    testInsert();
    testremove();
    testmempool();
    testformance();
    testconsume();
    std::cout << "Test Done,Hello, World!" << std::endl;
}

测试结果：

/home/dguco/Workspace/github/dsalgorithm/rbtarr_map/cmake-build-debug/rbtarr_map
==========================test rbtree start===================================
== 原始数据: ....100000个数太长了，此处省略
== 前序遍历: ....100000个数太长了，此处省略
== 后序遍历: ....100000个数太长了，此处省略
== 最大值: 2147408880
== test rbtree insert done
== test rbtree remove done
==========================test rbtree done===================================
==========================test insert start===================================
==========================test insert done===================================
==========================test remove begin===================================
==========================test remove done===================================
==========================test mempool begin===================================
==========================test mempool done===================================
---------------------------test performance begin---------------------------------------------
RbtHashMap<int,ValueType,1000000>[conflict count = 5], insert use  219 ms
RbtHashMap<int,ValueType,1000000>[conflict count = 5] find use  51 ms,res = 499999500000
RbtHashMap<int,ValueType,1000000>[conflict count = 10000], insert use  649 ms
RbtHashMap<int,ValueType,1000000>[conflict count = 10000] find use  75 ms,res = 499999500000
------------------------------------------------------------------------
std::map<int,ValueType> insert use  704 ms
std::map<int,ValueType> find use  308 ms,res = 499999500000
------------------------------------------------------------------------
std::unordered_map<int,ValueType> insert use  159 ms
std::unordered_map<int,ValueType> find use  62 ms,res = 499999500000
-----------------------------test performance done-------------------------------------------
-----------------------------test consume begin-------------------------------------------
test consume need time 60 S,please waiting
test consume last time 39 S,please waiting
consume inserting .....
consume removing .....
test consume last time 19 S,please waiting
consume inserting .....
consume removing .....
consume_insert remove count = 88001355
consume_insert insert count = 88008711
test consume keep time 60 S
-----------------------------test consume done-------------------------------------------
Test Done,Hello, World!

Process finished with exit code 0

       测试结果可以看到在插入和删除以及查找等操作上，这里都要比标准库的要好(当然这里的插入和删除没有像标准库那样有new和delete的开销)，但是查找大家都是一样的都不会有内存开销，甚至当冲突率达到10000（1000000个元素每10000个元素插入同一个hash中）它的查找效率依然比std::map高，几乎和unordered_map保持持平。

参考文章

基础优化-让哈希表更公平一些

红黑树(一)之 原理和算法详细介绍

红黑树(四)之 C++的实现

红黑树动画演示

漫画：什么是红黑树？

D_Guco
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
(001)HashMap之链表转红黑树-treefyBin方法.docx
06-17
详细解读了HashMap中链表转红黑树的treefyBin方法，该方法中涉及到的诸如：replacementTreeNode方法、treeify方法、comparableClassFor方法、compareComparables方法、tieBreakOrder方法、balanceInsertion方法、...
JDK 1.8之 HashMap 源码分析
crazy_jack
07-21 1798
转载请注明出处：http://blog.csdn.net/crazy1235/article/details/75579654构造函数 Node hash put treeifyBin get resize 参考与JDK1.7中HashMap的实现相比，JDK1.8做了如下改动： hash()函数算法修改 table数组的类型，由Entry改成了Node HashMap存储数据的结构由数组+链表，进
算法 第四版学习总结(超赞!!!)
热门推荐
FanceFu的博客
02-23 1万+
我是技术搬运工,好东西当然要和大家分享啦.原文地址第一章 基础栈数组实现public class ResizeArrayStack&lt;Item&gt; implements Iterable&lt;Item&gt; { private Item[] a = (Item[]) new Object[1]; private int N = 0; public void p...
JDK1.8 HashMap源码剖析
掘客DIGGKR
08-28 164
上篇我们介绍了JDK1.7版的HashMap，今天我们来讲解下JDK1.8版的HashMap。 JDK1.7的实现大家看出有没有需要优化的地方？ 其实一个很明显的地方就是：当 Hash 冲突严重时，在桶上形成的链表会变的越来越长，这样在查询时的效率就会越来越低；时间复杂度为 O(N)。 因此JDK1.8 中重点优化了这个查询效率。 1、JDK1.8 HashMap 数据结构图 我们会发现优化的部分就是把链表结构变成了红黑树。原来jdk1.7的优点是增删效率高，于是在jdk1.8的时候，不仅仅增删效率高，而
rbthash@glusterfs
glusterfs专栏
08-27 120
Glustefs里面有一个很有意思的数据结构叫做rbthash, 全称是red black tree hash, 顾名思义就是使用红黑树做的哈希， 这个数据结构在io-cache xlator的实现中用到。          首先，有红黑树数据结构（contirb/rbtree）， 它是从libavl库中偷过来的。虽然红黑树有点复杂，但是是相当经典的数据结构，有很多资料可以参考，这里就不展...
HashMap-链表与红黑树转换触发条件
weixin_37607613的博客
09-04 7768
JDK1.8对HashMap进行了很多优化。例如当一个槽位slot上的链表个数达到转换成红黑树的条件，则会将链表转换为红黑树。当一个槽位slot上的红黑树节点个数低至转换成链表的条件，则会将红黑树转换为链表。访问节点方式：先找到节点所在的数组slot位置，然后判断节点是什么结构进行遍历。链next红黑树nextprevroot。
(002)HashMap$TreeNode之往红黑树添加元素-putTreeVal方法.docx
06-18
HashMap之往红黑树添加元素-putTreeVal方法源码解读：当要put的元素所在数组索引位置已存在元素，且是红黑树类型时，就会调用putTreeVal方法添加元素到红黑树上，具体操作步骤如下： 1. 从根节点开始，到左右子树，...
HashMap的工作原理和底层实现（二）红黑树的左旋、右旋
01-07
HashMap中的红黑树左旋、右旋 摘要:  HashMap是java最常用的容器之一，本文会通过阅读源码的方式来理解HashMap中是如何进行红黑树的左旋和右旋 一、什么是左旋和右旋  红黑树的性质 每个节点要么是黑色，要么...
HashMap源码实现红黑树添加元素和删除元素
03-21
HashMap源码实现红黑树添加元素和删除元素
HashMap-hash原理
12-26
官方
c++11异步编程
D_Guco的专栏
04-23 1万+
c++11异步编程
c++ 性能优化策略
D_Guco的专栏
07-22 9871
1 关于继承：不可否认良好的抽象设计可以让程序更清晰，代码更看起来更好，但是她也是有损失的，在继承体系中子类的创建会调用父类的构造函数，销毁时会调用父类的析构函数，这种消耗会随着继承的深度直线上升，所以不要过度的抽象和继承，更为严重的是当多重继承中并且有虚函数的存在时情况更为复杂，的确,这些问题涉及开销,但是,多重继承减少了编码的负担,同时也让问题的解决方案更加简洁,这当然要付出一些代价.总之,与...
shared_ptr的线程安全性
D_Guco的专栏
05-01 9851
    shared_ptr的出现在某种程度上解放了c++程序员，c++11标准原生的支持了并发编程，在并发编程中shared_ptr的线程安全问题如何保证呢？先撇开shared_ptr对象的线程安全性，先看shared_ptr本身的线程安全问题。    我们知道，shared_ptr的底层实现原理是引用计数，关于这个计数是否线程安全呢，如果我们把shared_ptr分别传递到不同的线程中，是否会...
c++ 线程局部变量thread_local
D_Guco的专栏
01-20 9501
c++11 中添加了新的关键字thread_local,用来声明新的存储期(线程存储期变量)，即线程局部变量。 存储类指定符是名称声明语法的 decl-specifier-seq 的一部分。与名称的作用域一同，它们控制名称的二个独立属性：其“存储期”与其“链接”。auto - 自动存储期(C++11 起)。register - 自动存储期。亦提示编译器将此对象置于处理器的寄存器。C...
c++ placement new操作符的使用技巧
D_Guco的专栏
01-04 7418
在c++中new和delete操作是我们操作内存最常用的一对操作符，在使用new时编译器会申请内存，然后调用类的构造函数来初始化对象，调用delete会销毁对象同时释放该对象占用的内存，并且我们可以重载new操作符。 还有一个不常用的new操作placement new，在使用时需要我们传入一个指针，此时会在该指针指向的内存空间构造该对象，该指针指向的地址可以使堆空间，栈空间，也可以是静态存储区
atomic和volatile的操作的原子性
D_Guco的专栏
07-09 6718
c++11提供了atomic来实现无锁并发数据结构，用起来很简单。 #include #include #include #include using namespace std; //std::mutex mu_lock; //int num = 0; std::atomic num(0); void testThread1() { for ...
c++11 编译时类型判断
D_Guco的专栏
06-24 5823
    c++11中有一个特殊的模板类integral_constant，首先看实现： template&lt;typename _Tp, _Tp __v&gt; struct integral_constant { static constexpr _Tp value = __v; typedef _Tp ...
c++11之左值引用和右值引用
D_Guco的专栏
03-19 4807
  c++11中增加了右值引用和move语义来避免一些不必要的构造和copy操作，以此来提升程序的运行效率。首先说左值和右值，他们绝不是简单的等号左边和右边的区别，总结来说：   1 .左值可以寻址，而右值不可以。   2 .左值可以被赋值，右值不可以被赋值，可以用来给左值赋值。   3 左值可变,右值不可变（仅对基础类型适用，用户自定义类型右值引用可以通过成员函数改变）。   例：int...
hashmap红黑树
最新发布
09-07
哈希表（HashMap）是一种基于数组和链表（或红黑树）实现的数据结构，用于快速存取数据。红黑树是一种自平衡二叉查找树，它在插入、删除和查找操作上具有较好的性能。 在 Java 中，当哈希表中的某个桶（bucket）中元素的数量超过一定阈值时，就会将该桶转换为红黑树。这是为了解决哈希冲突引起的链表过长而导致查找效率下降的问题。 红黑树是一种特殊的二叉查找树，具有以下特点： 1. 每个节点都有一个颜色，红色或黑色。 2. 根节点和叶子节点（NIL节点）为黑色。 3. 如果一个节点是红色，则其子节点必须是黑色。 4. 从根节点到任意叶子节点的路径上，黑色节点数目相同。 5. 所有叶子节点都是NIL节点，并且不存储数据。 红黑树通过保持上述特性来实现自平衡。在插入和删除操作中，如果破坏了红黑树的特性，则需要进行相应的旋转和重新着色操作来修复。 通过使用红黑树作为哈希表的桶的数据结构，可以在最坏情况下保持O(log n)的插入、删除和查找操作时间复杂度，提高了哈希表的性能和稳定性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值