SGISTL源码探究-STL中的hashtable(下)

最新推荐文章于 2024-02-27 15:18:55 发布
最新推荐文章于 2024-02-27 15:18:55 发布
阅读量1k 收藏
点赞数
分类专栏： STL相关 STL源码探究 文章标签： STL 源码分析 hashtable 插入-删除 重建
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Move_now/article/details/78023792
版权

前言

在上一小节中,我们介绍了hashtable的基本概念,以及分析了在STL中,hashtable的迭代器、采用的数据结构及它的构造/析构函数,还有部分成员函数。
在本小节中,我们讲继续分析剩下的一些操作,如插入、删除、复制等。

插入操作

关于插入操作,有大量的重载版本,我们只分析比较关键的函数,其他的可以随便看看。

/* insert_unique,插入元素(不允许重复)
 * 首先先判断加上新增元素之后,需不需要重新建表(关于判断是否需要重新建表的标准,我们放在下面分析)
 * 然后调用insert_unique_noresize进行插入
 */
pair<iterator, bool> insert_unique(const value_type& obj)
{
  resize(num_elements + 1);
  return insert_unique_noresize(obj);
}
/* 插入元素(允许重复的元素)
 * 可以看到调用的插入元素的函数成了insert_equal_noresize
 */
iterator insert_equal(const value_type& obj)
{
  resize(num_elements + 1);
  return insert_equal_noresize(obj);
}

//定义
pair<iterator, bool> insert_unique_noresize(const value_type& obj);
iterator insert_equal_noresize(const value_type& obj);

/* 重载版本,范围插入
 * 看看就好,主要还是调用的resize还有对应的插入函数
 */
......
void insert_unique(const value_type* f, const value_type* l)
{
  size_type n = l - f;
  resize(num_elements + n);
  for ( ; n > 0; --n, ++f)
    insert_unique_noresize(*f);
}

void insert_equal(const value_type* f, const value_type* l)
{
  size_type n = l - f;
  resize(num_elements + n);
  for ( ; n > 0; --n, ++f)
    insert_equal_noresize(*f);
}

void insert_unique(const_iterator f, const_iterator l)
{
  size_type n = 0;
  distance(f, l, n);
  resize(num_elements + n);
  for ( ; n > 0; --n, ++f)
    insert_unique_noresize(*f);
}

void insert_equal(const_iterator f, const_iterator l)
{
  size_type n = 0;
  distance(f, l, n);
  resize(num_elements + n);
  for ( ; n > 0; --n, ++f)
    insert_equal_noresize(*f);
}
.......

/* insert_unique调用的真正实施插入操作的函数
 * 首先通过btk_num获取到放入hashtable的位置
 * 然后遍历该链表
 * 依次调用equals判断key是否相等
 * 由于不允许重复,所以如果有与obj的key相等的直接返回
 * 并将pair的第一个元素置成指向该重复的节点的迭代器,第二个元素置为false
 * 没有重复的才执行插入操作
 */
template <class V, class K, class HF, class Ex, class Eq, class A>
pair<typename hashtable<V, K, HF, Ex, Eq, A>::iterator, bool>
hashtable<V, K, HF, Ex, Eq, A>::insert_unique_noresize(const value_type& obj)
{
  const size_type n = bkt_num(obj);
  node* first = buckets[n];

  for (node* cur = first; cur; cur = cur->next)
    if (equals(get_key(cur->val), get_key(obj)))
      return pair<iterator, bool>(iterator(cur, this), false);

  //配置一个新的值为obj的节点
  node* tmp = new_node(obj);
  //链表的头插法
  tmp->next = first;
  buckets[n] = tmp;
  //节点数加1
  ++num_elements;
  //返回指向该节点的迭代器
  return pair<iterator, bool>(iterator(tmp, this), true);
}

/* 该函数供insert_equal调用,允许拥有重复的key的元素插入
 * 前面和后面的操作都和上面的一样
 * 只是当检测到插入的元素的key和已有的重复时
 * 做的操作是将插入的元素放到已有的元素后
 * 然后返回
 */
template <class V, class K, class HF, class Ex, class Eq, class A>
typename hashtable<V, K, HF, Ex, Eq, A>::iterator
hashtable<V, K, HF, Ex, Eq, A>::insert_equal_noresize(const value_type& obj)
{
  const size_type n = bkt_num(obj);
  node* first = buckets[n];

  for (node* cur = first; cur; cur = cur->next)
    if (equals(get_key(cur->val), get_key(obj))) {
      node* tmp = new_node(obj);
      tmp->next = cur->next;
      cur->next = tmp;
      ++num_elements;
      return iterator(tmp, this);
    }

  node* tmp = new_node(obj);
  tmp->next = first;
  buckets[n] = tmp;
  ++num_elements;
  return iterator(tmp, this);
}

resize

该函数用于判断是否需要重新建表,注意不是调用了就重建表。
它的判断标准是:把元素个数和bucket个数来比较,如果前者大于后者,就重建表。
这就意味着,每个bucket的链表最大的节点数和bucket的个数相同。

template <class V, class K, class HF, class Ex, class Eq, class A>
void hashtable<V, K, HF, Ex, Eq, A>::resize(size_type num_elements_hint)
{
  const size_type old_n = buckets.size();
  //如果节点个数大于bucket个数,则重建
  if (num_elements_hint > old_n) {
    //求出下一个合适的n
    const size_type n = next_size(num_elements_hint);
    /* 若n大于旧的bucket个数时才进行重建 */
    if (n > old_n) {
      //新的hashtable
      vector<node*, A> tmp(n, (node*) 0);
      __STL_TRY {
        /* 下面执行节点迁移操作
         * 首先遍历bucket
         * 然后遍历bucket中的链表
         * 进行节点迁移
         */
        for (size_type bucket = 0; bucket < old_n; ++bucket) {
          node* first = buckets[bucket];
          while (first) {
            //将旧表上的节点需要插入到新表上的位置算出来
            size_type new_bucket = bkt_num(first->val, n);
            //然后将该节点移出旧表
            buckets[bucket] = first->next;
            //与新表进行连接
            first->next = tmp[new_bucket];
            tmp[new_bucket] = first;
            first = buckets[bucket];     
          }
        }
        //最后将旧表与新表进行交换
        //旧表的空间会随着tmp离开其作用域而释放
        buckets.swap(tmp);
      }
#         ifdef __STL_USE_EXCEPTIONS
      //下面是产生异常的情况
      catch(...) {
        for (size_type bucket = 0; bucket < tmp.size(); ++bucket) {
          while (tmp[bucket]) {
            node* next = tmp[bucket]->next;
            delete_node(tmp[bucket]);
            tmp[bucket] = next;
          }
        }
        throw;
      }
#         endif /* __STL_USE_EXCEPTIONS */
    }
  }
}

clear

析构函数中调用的函数,用于释放所有节点。(vector的空间并未被释放)

template <class V, class K, class HF, class Ex, class Eq, class A>
void hashtable<V, K, HF, Ex, Eq, A>::clear()
{
  //遍历每个bucket
  for (size_type i = 0; i < buckets.size(); ++i) {
    //遍历链表
    node* cur = buckets[i];
    while (cur != 0) {
      //释放节点
      node* next = cur->next;
      delete_node(cur);
      cur = next;
    }
    //最后将该bucket置为null
    buckets[i] = 0;
  }
  //将num_elements置成0
  num_elements = 0;
}

复制操作

拷贝构造函数里面唯一调用的函数

template <class V, class K, class HF, class Ex, class Eq, class A>
void hashtable<V, K, HF, Ex, Eq, A>::copy_from(const hashtable& ht)
{
  //首先将原空间的节点全部清除
  buckets.clear();
  //然后根据ht的大小来适当扩展hashtable的空间(reverse不会缩小空间)
  buckets.reserve(ht.buckets.size());
  //调用insert对hashtable进行初始化
  buckets.insert(buckets.end(), ht.buckets.size(), (node*) 0);
  __STL_TRY {
    //接下来,我们只需要遍历bucket以及bucbucket上的链表,将每个节点拷贝过去就行了
    for (size_type i = 0; i < ht.buckets.size(); ++i) {
      //该bucket不为空,进行拷贝
      if (const node* cur = ht.buckets[i]) {
        //创建新的节点
        node* copy = new_node(cur->val);
        //令新的节点为bucket的头节点
        buckets[i] = copy;

        //依次创建新节点,并连接到该bucket上
        for (node* next = cur->next; next; cur = next, next = cur->next) {
          copy->next = new_node(next->val);
          copy = copy->next;
        }
      }
    }
    //维护num_elements
    num_elements = ht.num_elements;
  }
  __STL_UNWIND(clear());
}

查找元素,若没有则插入

template <class V, class K, class HF, class Ex, class Eq, class A>
typename hashtable<V, K, HF, Ex, Eq, A>::reference
hashtable<V, K, HF, Ex, Eq, A>::find_or_insert(const value_type& obj)
{
  //首先判断是否需要重建表,因为可能涉及到插入操作
  resize(num_elements + 1);

  size_type n = bkt_num(obj);
  node* first = buckets[n];

  //遍历该key所在的bucket,如果找到了,则直接返回
  for (node* cur = first; cur; cur = cur->next)
    if (equals(get_key(cur->val), get_key(obj)))
      return cur->val;
  //否则,插入该obj
  node* tmp = new_node(obj);
  tmp->next = first;
  buckets[n] = tmp;
  ++num_elements;
  return tmp->val;
}

删除操作

关于erase操作,也有很多重载的版本,无非就是针对某个值进行删除以及针对某个迭代器指向的位置进行删除、还有根据迭代器的范围进行删除或者删除n个元素之类的。
这里我们只分析前两种。

//根据key值删除,返回删除的个数(因为可能允许重复的元素插入,所以一个key可能对应多个元素)
template <class V, class K, class HF, class Ex, class Eq, class A>
typename hashtable<V, K, HF, Ex, Eq, A>::size_type
hashtable<V, K, HF, Ex, Eq, A>::erase(const key_type& key)
{
  //获取该key对应hashtable存储的位置
  const size_type n = bkt_num_key(key);
  //指向该bucket的第一个节点
  node* first = buckets[n];
  //erased记录删除的节点个数
  size_type erased = 0;

  //若要删除的key对应的元素还没有插入,直接返回0,代表删除的个数为0
  if (first) {
    //遍历链表
    node* cur = first;
    node* next = cur->next;
    while (next) {
      //找到key值相同的节点
      if (equals(get_key(next->val), key)) {
        //将该节点移出,并释放
        cur->next = next->next;
        delete_node(next);
        next = cur->next;
        //删除的节点个数加1
        ++erased;
        //总的节点数减1
        --num_elements;
      }
      else {
        cur = next;
        next = cur->next;
      }
    }
    //比较该key与第一个节点的key
    if (equals(get_key(first->val), key)) {
      buckets[n] = first->next;
      delete_node(first);
      ++erased;
      --num_elements;
    }
  }
  //返回成功删除的节点个数
  return erased;
}

//删除迭代器指向的节点
template <class V, class K, class HF, class Ex, class Eq, class A>
void hashtable<V, K, HF, Ex, Eq, A>::erase(const iterator& it)
{
  if (node* const p = it.cur) {
    const size_type n = bkt_num(p->val);
    node* cur = buckets[n];
    /* 如果删除的就是目前bucket的第一个节点
     * 需要特殊处理一下,将cur->next设为新的头节点
     */
    if (cur == p) {
      buckets[n] = cur->next;
      delete_node(cur);
      --num_elements;
    }
    else {
      /* 否则遍历该链表
       * 找到要删除的节点进行删除
       */
      node* next = cur->next;
      while (next) {
        if (next == p) {
          cur->next = next->next;
          delete_node(next);
          --num_elements;
          break;
        }
        else {
          cur = next;
          next = cur->next;
        }
      }
    }
  }
}

小结

关于hashtable部分,本小节已经将剩下的大部分操作分析完了,关于stl_hash_fun.h中哈希函数对象部分的内容,有兴趣的可以自己看看,其实就是通过重载()操作符完成的,里面集成了根据key的类型不同的各种不同的哈希函数,比如key是字符串,就需要进行一定的转换了。并且SGISTL中的hashtable无法处理string这类的key,需要用户来定义它们的哈希函数。
在下一小节中,我们将对hash_set进行分析。

UKey_
关注
专栏目录
STL-----hashtable的原理与实现
qq_41983709的博客
11-22 474
hash table 可提供对任何有名项的存取和删除操作。由于操作对象是有名项，所以hash table也可被视为一种字典结构。这种结构的用意在于提供常数时间的基本操作。它将这些有名项存放在桶中，各桶单元在物理上是连续排列的。 比如某学校拟建立一个电话簿查询系统，假设该校总共约25000门固定电话，每个电话都是8位的，我们怎么样才能实习将这些固定电话放入桶中，使得查询，插入，删除都是常数时间呢？...
SGISTL源码探究-STL中的hashtable(上)
Move_now的博客
09-18 1340
前言关于哈希表部分,哈希函数以及解决哈希冲突的方法都有很多种,在本文中不会详细去讨论哈希表的大量知识,而是以SGISTL实现的hashtable为主,所以如果对hashtable不太了解,建议先去网上查阅相关的资料。这里只给出基本的概念。了解哈希表原理基本概念哈希表(hashtable,也称散列表):根据key来访问元素的一种数据结构。它可能先经过哈希函数计算出key,然后通过key访问表中对应ke
STL源码剖析 hashtable
CHYabc123456hh的博客
11-26 1003
二叉搜索树具有对数平均时间的表现，但是这个需要满足的假设前提是输入的数据需要具备随机性 hashtable 散列表这种结构在插入、删除、搜寻等操作层面上也具有常数平均时间的表现。而且不需要依赖元素的随机性，这种表现是以统计为基础的 hashtable的概述 hashtable可提供对任何有名项的存取和删除操作 因为操作的对象是有名项，因此hashtable可以作为一种字典结构 将一个元素映射成为一个 “大小可以接受的索引”简称为hash function散列函数 考虑到元素的个数大于array的容
私房STL之Hashtable
lionzl的专栏
02-27 604
私房STL之Hashtable 2 条回复 一句话之Hashtable：哈希表（散列表）能通过键值对数据进行访问的数据结构；其在C++0X标准中未出现，可能是考虑到哈希表效率低下，出于其广泛用于工程中，C++11将其纳入了标准库。C++11的新特性：http://en.wikipedia.org/wiki/C%2B%2B11，C++11中哈希表的说明：http://en.wikiped
STL源码剖析（五）hashtable
小二笙的博客
12-02 607
文章目录1. hashtable概述1.1 线性探测1.2 二次探测1.3 开链法2. hashtable的桶与节点3. hashtable迭代器4. hashtable数据结构5. hashtable构造与内存管理6. 元素操作7. hash functions 1. hashtable概述 hashtable，即我们在数据结构中所说的散列表，也叫哈希表，在插入、删除、搜寻等操作上具有“常数平...
SGI STL源码.zip
12-14
在解压后的"STL源码"文件中，我们可以看到SGI STL的实现细节。源码通常包括了以下部分： 1. 容器的实现：每个容器都有自己的内部结构和管理元素的方式。例如，vector使用动态数组，list使用双向链表，set和map使用...
SGI-STL-.rar_STL_sgi stl
09-21
这个压缩包“SGI-STL-.rar_STL_sgi stl”包含了SGI（Silicon Graphics, Inc.）版本的STL源码，这是一个经典的STL实现，对深入理解STL的内部工作原理非常有帮助。STL由Alexander Stepanov和Menas C. Kafatos在1985年...
STL:SGI STL源码-注释版
03-24
本资源“STL: SGI STL源码-注释版”提供了一份详尽的SGI STL源码，并附带了注释，这对于深入理解STL的工作原理以及如何优化C++代码极其宝贵。 STL的核心组件包括容器、迭代器、算法和函数对象。以下是对这些组件的...
tass-sgi-stl-2.91.57-source.zip
08-21
在这个名为"tass-sgi-stl-2.91.57-source.zip"的压缩包中，包含的是SGI STL（Silicon Graphics Incorporated的STL实现）的2.91.57版本的源码，这是一个经典且广泛参考的STL实现。这个源码库对于深入理解STL的工作...
c++ SGI STL源代码学习
06-04
- 探究算法的底层实现，如快速排序、归并排序等复杂算法的C++实现，以及它们在STL中的优化策略。 - 了解函数对象的实现，包括如何自定义函数对象以满足特定需求，以及它们如何与算法配合工作。 此外，通过阅读源...
哈希表应用C++_STL_hash
12-14
哈希表应用C++_STL_hash 哈希表应用C++_STL_hash 哈希表应用C++_STL_hash
SGI-STL(version3.3)
08-29
这个是SGI实现的STL版本，版本是3.3，。仅供参考。
STL源码分析之hashtable
博客
06-07 614
二叉搜索树具有对数平均时间的表现，但这样的表现构造在一个假设上:输入数据有足够的随机性 这里我们要介绍的是散列表数据结构，这种结构在插入、删除、搜寻等操作上具有“常数平均时间”的表现，而且这种表现是以统计为基础，不需要仰赖输入元素的随机性   Hash table提供对任何有名项的存取操作和删除操作。由于操作对象是有名项，所有hashtable可被视为一种字典结构。   hashtabl
STL源码剖析－关联式容器之hashtable
oyhy_的博客
04-20 406
１．hashtable在插入，删除，搜寻操作上具有＂常数平均时间＂的表现，不依赖输入元素的随机性．２．hashtable通过hashfunction将元素映射到不同的位置，但当不同的元素通过hash function映射到相同位置时，便产生了＂碰撞＂问题．解决碰撞问题的方法主要有线性探测，二次探测，开链法等．３．线性探测当hash function计算出某个元素的插入位置，而该位置的空间已不可用时，
STL源码阅读-hashtable
飞鸟
07-28 634
hashtable能够提供线性时间的访问速度，
C++ STL（第十五篇：hashtable）
热门推荐
weixin_39640298的博客
04-19 1万+
1、hashtable hashtable 的目的是为了提供任何操作都是常数级别。SGI STL 中， hash table 使用了 开链法 实现的。大致的意思如下图所示： hash table 内的元素为 桶子（bucket），每个桶子里面有很多节点。其实有点像我们前面整理的 deque（双端队列），双端队列主控是个指向指针的指针，而hash table是一个vector；双端队列缓冲区是一块...
C++STL哈希表
qq_62745420的博客
10-08 2058
哈希算法是如何不通过比较就能确定一个数据在不在呢？答案是：通过将数据插入的位置与关键字建立映射关系，这种映射关系就是后面要说到的哈希函数简单举个例子：现在有这样一个场景，给你了一个长度为N的字符串，需要你在O（N）的时间复杂度内找出所有只出现过一次的字符。这时候我们就可使用哈希算法中的直接定址法来解决。什么是直接定址法呢？就是我们创建一个长度为128的计数数组，然后用字符的ascii码值直接映射到数组的这个位置，对这个位置进行++。
C++ STL：hashtable源码分析
最新发布
暮色年华的博客
02-27 1083
当hashtable中插入的元素个数大于当前vector的容量时，会新建一个vector，新vector的容量是之前vector容量所在质数表里的下一个质数，如53的后一个是97，新vector的容量为97。函数将不同类型的key数据转换成统一的数值格式（如：const char *转换成特定的数值），以便hash函数进行取模处理，取模用的模值就是桶的数量值，也就是vector的容量。m不应该是进制数的幂，比如十进制的时候，m如果是10^n，那么结果总是和原始值的后n位相关的，这样冲突的概率会更大。
C++进阶——STL源码之hashtable
qq_25065595的博客
09-04 1173
STL源码之hashtable hashtable 是一种在插入、删除、搜寻等操作上也具有 “常数平均时间”（散列表）的数据结构，而且这种表现是以统计为基础，不需依赖输入元素的随机性。 STL中hashtable是实现hash_map和hash_set的底层。它解决冲突的方式是开链法，每个放置索引值的节点称为桶节点（也就是该索引值的头结点），桶节点里放着一个value值，一个指向下一个节点的next指针。 维护了一个vector<node *> buckets存放所有桶节点，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值