从零开始写STL—哈希表

最新推荐文章于 2024-03-25 22:53:22 发布
最新推荐文章于 2024-03-25 22:53:22 发布
阅读量91 收藏
点赞数
原文链接：http://www.cnblogs.com/joeylee97/p/8877254.html
版权 
static const int _stl_num_primes = 28;
    template<typename T, typename Hash = xhash<T>>
    class hashtable;

     ministl::vector<int> prime_list = 
    {
        53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593, 49157, 98317, 196613, 393241,
        786433, 1572869, 3145739, 6291469, 12582917, 25165843, 50331653, 100663319, 201326611,
        402653189, 805306457, 1610612741, 3221225473, 4294967291,
    };

    template<typename T>
    class hash_iterator : public bidirectional_iterator<T>
    {
    public:
        hashtable<T>* hash_ptr;
        list_iterator<T> node_ptr;
        list<T>* bucket_ptr;
        hash_iterator(hashtable<T>* hp, list<T>* bp, list_iterator<T> np) :hash_ptr(hp), bucket_ptr(bp), node_ptr(np) {}
        
        hash_iterator& operator++()
        {
            if (++node_ptr == bucket_ptr->end())
            {
                auto tmp = node_ptr;
                --tmp;
                size_t cur = hash_ptr->hash(*tmp, hash_ptr->bucket_size()) + 1;
                while (cur < hash_ptr->bucket_size() && (*hash_ptr).data[cur].empty())
                    cur++;
                bucket_ptr = cur < hash_ptr->bucket_size() ? &(hash_ptr->data[cur]) : hash_ptr->data.end();
                node_ptr = (bucket_ptr == hash_ptr->data.end() ? nullptr : bucket_ptr->begin());
            }
            return *this;
        }

        hash_iterator operator++(int)
        {
            hash_iterator tmp = *this;
            ++*this;
            return tmp;
        }

        hash_iterator& operator--()
        {
            if (node_ptr-- = bucket_ptr->begin())
            {
                size_t cur = hash_ptr->hash(*node_ptr, hash_ptr->bucket_size()) - 1;
                if (cur < 0) cur = 0;
                else
                {
                    while (cur >= 0 && (*hash_ptr).data[cur].empty())
                        cur--;
                }
                bucket_ptr = &(hash_ptr->data[cur]);
                node_ptr =  bucket_ptr->begin();
            }
            return *this;
        }

        hash_iterator operator--(int)
        {
            hash_iterator tmp = *this;
            --*this;
            return tmp;
        }

        T& operator* ()
        {
            return *node_ptr;
        }

        bool operator==(const hash_iterator& rhs)
        {
            return hash_ptr == rhs.hash_ptr && node_ptr == rhs.node_ptr && bucket_ptr == rhs.bucket_ptr;
        }

        bool operator!=(const hash_iterator& rhs)
        {
            return !(*this == rhs);
        }
    };

    template<typename T,typename Hash = xhash<T> >
    class hashtable
    {
        friend class hash_iterator<T>;
    public:
        typedef T value_type;
        typedef Hash hash_type;
        typedef vector<list<T>> table;
        typedef hash_iterator<T> iterator;
    private:
        Hash hash;
        table data;
        size_t elem_num;//the sum of all elements
        pair<iterator, bool> _insert_unique_noresize(T val)
        {
            size_t index = hash(val, data.size());

            for (auto it = data[index].begin(); it != data[index].end(); it++)
            {
                if (*it == val)
                    return make_pair<iterator, bool >(iterator(this, &data[index], it), false);
            }
            
            data[index].push_front(val);
            elem_num++;
            return make_pair<iterator, bool>(iterator(this, &data[index], data[index].begin()), true);
        }
        
        iterator _insert_equal_noresize(T val)
        {
            size_t index = hash(val, data.size());
            for (auto it = data[index].begin(); it != data[index].end(); it++)
            {
                if (*it == val)
                {
                    return iterator(this, &data[index], data[index].insert(it, val));
                }
            }
            data[index].push_front(val);
            elem_num++;
            return iterator(this, &data[index], data[index].begin());
        }

        void initialize_buckets(size_t n)    
        {
            data.resize(n);
            elem_num = 0;
        }

    public:
        hashtable()
        {
            initialize_buckets(53);
        }
        hashtable(size_t n)
        {
            initialize_buckets(next_prime(n));
        }

        void clear()
        {
            for (auto& it : data) 
            {
                it.clear();
            }
            elem_num = 0;
        }

        bool empty()
        {
            return elem_num == 0;
        }

        pair<iterator, bool>find(const T& val)
        {
            size_t index = hash(val, data.size());

            for (auto it = data[index].begin(); it != data[index].end(); it++)
            {
                if (*it == val)
                    return ministl::make_pair<iterator, bool >(iterator(this, &data[index], it), true);
            }

            return ministl::make_pair<iterator, bool >(end(), false);
        }


        iterator begin() const
        {
            auto it = data.begin();
            while (it != data.end() && it->empty())
                it++;
            return iterator(const_cast<hashtable<T>*>(this), it, it == data.end() ? nullptr : it->begin());
        }

        iterator begin()
        {
            auto it = data.begin();
            while (it != data.end() && it->empty())
                it++;
            return iterator(this, it, it == data.end() ? nullptr : it->begin());
        }

        iterator end() const
        {
            return iterator(const_cast<hashtable<T>*>(this), data.end(), nullptr);
        }

        iterator end()
        {
            return iterator(this, data.end(), nullptr);
        }


        inline unsigned long next_prime(unsigned long n)
        {
            for (auto it : prime_list)
            {
                if (it >= n)
                    return n;
            }
            return prime_list[_stl_num_primes - 1];
        }

        size_t bucket_size() 
        {
            return data.size();
        }

        size_t bucket_size() const
        {
            return data.size();
        }

        size_t size()
        {
            return elem_num;
        }
        size_t hash_val(const T& val)
        {
            return hash(val, data.size());
        }
        pair<iterator, bool> insert_unique(T val)
        {
            rehash(elem_num + 1);
            return _insert_unique_noresize(val);
        }

        iterator insert_equal(T val)
        {
            rehash(elem_num + 1);
            return _insert_equal_noresize(val);
        }

        iterator erase_iter(iterator pos)
        {
            iterator ret = pos;
            ret++;
            pos.bucket_ptr->erase(pos.node_ptr);
            return ret;
        }

        void erase_val(const T& val)
        {
            size_t index = hash(val, data.size());
            for (auto it = data[index].begin(); it != data[index].end();)
            {
                if (*it == val)
                    it = data[index].erase(it);
                else
                    it++;

            }
        }

        void rehash(size_t n)
        {
            if (n > bucket_size())
            {
                elem_num = elem_num ? elem_num:1;
                while (n > elem_num) elem_num *= 2;
                size_t new_size = next_prime(elem_num);
                hashtable new_table(new_size);
                if (!empty())
                {
                    iterator it = begin();
                    for (; it != end(); it++)
                    {
                        //std::cout << *it << std::endl;
                        new_table.insert_equal(*it);
                    }
                }
                swap(*this, new_table);
            }
        }

        hashtable& operator=(const hashtable& rhs)
        {
            clear();
            for (auto it = rhs.begin(); it != rhs.end(); it++)
            {
                insert_equal(*it);
            }
            return *this;
        }
    };

    template<typename T>
    void swap(const hashtable<T>& lhs, const hashtable<T>& rhs)
    {
        using ministl::swap;
        swap(lhs.data, rhs.data);
        swap(lhs.elem_num, rhs.elem_num);
        swap(lhs.hash, rhs.hash);
    }


    template<typename T, typename Hash = xhash<T> >
    class unordered_set
    {
    public:
        typedef T value_type;
        typedef Hash hash_type;
        typedef vector<list<T>> table;
        typedef hash_iterator<T> iterator;
        typedef hashtable<T> seq;
    private:
        seq con;
    public:
        unordered_set() :con() {}
        unordered_set(std::initializer_list<T> l)
        {
            unordered_set();
            insert(l.begin(), l.end());
        }
        iterator begin()
        {
            return con.begin();
        }

        iterator end()
        {
            return con.end();
        }

        iterator find(const value_type& key)
        {
            return con.find(key).first;
        }

        iterator insert(const value_type& key)
        {
            return con.insert_unique(key).first;
        }

        iterator insert(value_type& key)
        {
            return con.insert_unique(key);
        }
        template <class InputIterator>
        void insert(InputIterator first, InputIterator last)
        {
            for (auto it = first; it != last; it++)
                insert(*it);
        }

        size_t erase(const value_type& key)
        {
            size_t num = count(key);
            if(num)
                con.erase_val(key);
            return num;
        }

        iterator erase(const iterator it)
        {
            return con.erase_iter(it);
        }

        iterator erase(const iterator first, const iterator last)
        {
            iterator it = first;
            for (; it != last;)
                it = con.erase_iter(it);
            return it;
        }

        size_t count(const value_type& val)
        {
            return (con.find(val).second == true) ? 1 : 0;
        }

        bool empty()
        {
            return con.empty();
        }

        size_t size()
        {
            return con.size();
        }

        void clear()
        {
            con.clear();
        }

        void swap(unordered_set<T>& rhs)
        {
            using ministl::swap;
            swap(con, rhs.con);
        }

        size_t bucket_count()
        {
            return con.bucket_size();
        }

        void rehash()
        {
            con.rehash(con.elem_num + 1);
        }

        double load_factor()
        {
            return 1.0 * con.elem_num / bucket_count();
        }

    };

    //Todo: map_pair的hashval
    //模板特化无法匹配？
    template<typename K , typename T, typename Hash = xhash<map_pair<K,T>> >
    class unordered_map
    {
    public:
        typedef K key_type;
        typedef T value_type;
        typedef Hash hash_type;
        typedef vector<list<map_pair<K,T>>> table;
        typedef hash_iterator<map_pair<K,T>> iterator;
        typedef hashtable<map_pair<K, T>, xhash<map_pair<K, T>> > seq;
    private:
        seq con;
    public:
        unordered_map() :con() {}
        
        iterator begin()
        {
            return con.begin();
        }
        iterator begin() const
        {
            return con.begin();
        }

        iterator end()
        {
            return con.end();
        }
        iterator end() const
        {
            return con.end();
        }

        value_type& operator[](const key_type& key)
        {
            map_pair<K, T> p(key, T());
            auto tmp = con.find(p);
            iterator it = tmp.first;
            if (tmp.second == false)
            {
                it = con.insert_equal(p);
            }
            return (*it).second;

        }

        value_type& at(const key_type& key)
        {
            auto tmp = con.find(key);
            if (tmp.second == false)
            {
                std::cerr << "unordered_map out of range \n";
                std::exit(1);
            }
            return (*it).second;
        }

        const value_type& at(const key_type& key) const
        {
            auto tmp = con.find(key);
            if (tmp.second == false)
            {
                std::cerr << "unordered_map out of range \n";
                std::exit(1);
            }
            return (*it).second;
        }

        iterator find(const key_type& key)
        {
            return con.find(key).first;
        }

        pair<iterator, iterator>
            equal_range(const key_type& k)
        {
            auto first = con.find(k).first;
            if (first == con.end())
                return make_pair<iterator, iterator>(first, first);
            else
            {
                iterator last = ++first;
                while (last != con.end() && (*last == *first))
                {
                    last++;
                }
                return make_pair<iterator, iterator>(first, last);
            }
        }

        size_t count(const key_type& k)
        {
            auto first = con.find(k).first;
            if (first == con.end())
                return 0;
            else
            {
                iterator last = ++first;
                size_t cnt = 1;
                while (last != con.end() && (*last == *first))
                {
                    last++, cnt++;
                }
                return cnt;
            }
        }

        auto insert(const map_pair<K, T> p)
        {
            return con.insert_unique(p);
        }

        size_t erase(const value_type& key)
        {
            size_t num = count(key);
            if (num)
                con.erase_val(key);
            return num;
        }

        iterator erase(const iterator it)
        {
            return con.erase_iter(it);
        }

        iterator erase(const iterator first, const iterator last)
        {
            iterator it = first;
            for (; it != last;)
                it = con.erase_iter(it);
            return it;
        }

        void rehash(size_t n)
        {
            con.rehash(n);
        }

    };

转载于:https://www.cnblogs.com/joeylee97/p/8877254.html

aocan6909
关注
STL（六）——hashtable(一)：哈希介绍与部分STL实现
Pokemon_Master的博客
09-10 366
hashtable概述 hashtable是一种以空间换时间的数据结构，哈希函数让hashtable在插入、删除、搜索等操作上有“常数平均时间”的表现，因此很受欢迎。   hashtable的冲突解决 使用hash function会带来一个问题：可能有不同的元素被映射到相同的位置。有几种解决办法，我们一一介绍。 一. 线性探测（linear——probing） 当hash funct...
＜stl系列＞哈希表详解，掌握stl容器从现在开始
weixin_59371851的博客
09-22 1994
哈喽，小伙伴们大家好，今天我们来学习几个新的容器。这几个容器存储和查找数据效率是非常高的，能达到非常理想的O(1)，这主要因为它们采用了哈希的思想。那么事不宜迟，我们一起来看看吧。一、unordered系列关联式容器c++中容器分为序列式容器和关联式容器。所谓序列容器，就是以线性排列来排列某种类型的数据，比如vect，list，dequene。序列式容器通常只是单纯的用来存储数据。
请你来说一说hash表的实现，包括STL中的哈希桶长度常数
WangY.H
06-30 1415
参考回答： hash表的实现主要包括构造哈希和处理哈希冲突两个方面： （1） 对于构造哈希来说，主要包括直接地址法、平方取中法、除留余数法等。 （2） 对于处理哈希冲突来说，最常用的处理冲突的方法有开放定址法、再哈 希法、链地址法、建立公共溢出区等方法。SGL版本使用链地址法，使用一个 链表保持相同散列值的元素。虽然链地址法并不要求哈希桶长度必须为质数， 但SGI STL仍然以质数来...
STL ④ —— 哈希
最新发布
qq_51148151的博客
03-25 811
详细介绍了哈希表的底层机制
STL容器：哈希表
李志杰的博客
03-23 642
// 计算哈希值的类 template<typename T> class CHash { public: int operator()(const T &val) { // 默认用除留余数法 return val; } }; // string User People // 线性探测法实现的哈希表结构 template<typename T, ...
【C++】STL --- 哈希
YoungMLet的博客
11-29 2277
了解 unordered_map/unordered_set 的使用和简单实现哈希！介绍哈希的应用 --- 位图和布隆过滤器！
专题四：哈希表
wmy01234的博客
05-09 599
一、基础知识 哈希表是根据关键码的值而直接进行访问的数据结构。 那么哈希表能解决什么问题呢，「一般哈希表都是用来快速判断一个元素是否出现集合里。」 例如要查询一个名字是否在这所学校里。 要枚举的话时间复杂度是O(n)，但如果使用哈希表的话， 只需要O(1) 就可以做到。 我们只需要初始化把这所学校里学生的名字都存在哈希表里，在查询的时候通过索引直接就可以知道这位同学在不在这所学校里了。 将学生姓名映射到哈希表上就涉及到了「hash function ，也就是哈希函数」。 哈希函数 哈希碰撞 一般哈希碰
c ++中哈希表如何访问_C / C ++中的哈希表–完整的实现
从零开始的教程世界
07-20 1397
c ++中哈希表如何访问A Hash Table in C/C++ (Associative array) is a data structure that maps keys to values. This uses a hash function to compute indexes for a key. C / C ++中的哈希表 （ 关联数组 ）是一种将键映射到值的数据结构。 这使用哈希函...
从零开始学C++之STL（一）：STL六大组件简介
Meditation
07-22 9388
一、STL简介 （一）、泛型程序设计 泛型编程（generic programming） 将程序写得尽可能通用 将算法从数据结构中抽象出来，成为通用的 C++的模板为泛型程序设计奠定了关键的基础 （二）、什么是STL 1、STL（Standard Template Library），即标准模板库，是一个高效的C++程序库。 2、包含了诸多在计算机科学领域里常用的
C++ 哈希
m0_61548909的博客
08-27 2849
在 C++98 中， STL 提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 $log_2N$，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11 中， STL 又提供了 4 个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对unordered_map 和 unordered_set 进行介绍，unordered_multimap和
C++STL哈希表
qq_62745420的博客
10-08 2062
哈希算法是如何不通过比较就能确定一个数据在不在呢？答案是：通过将数据插入的位置与关键字建立映射关系，这种映射关系就是后面要说到的哈希函数简单举个例子：现在有这样一个场景，给你了一个长度为N的字符串，需要你在O（N）的时间复杂度内找出所有只出现过一次的字符。这时候我们就可使用哈希算法中的直接定址法来解决。什么是直接定址法呢？就是我们创建一个长度为128的计数数组，然后用字符的ascii码值直接映射到数组的这个位置，对这个位置进行++。
hash表
aa838260772的专栏
09-09 378
StringHash.h #include #include using namespace std; #pragma once #define MAXTABLELEN 1024 // 默认哈希索引表大小 /////////////////////////////////////////////////////////////////////////
二叉树 STL 图 哈希 详解
Meikesibondwell的博客
08-04 677
Ubuntu Pastebin Paste from QWbin at Wed, 26 Jul 2017 10:36:33 +0000 Download as text 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
哈希表原理及stl中的简单用法
m0_62467316的博客
04-11 505
哈希表又叫做散列表，提供了快速插入操作和查找操作，无论数据多少，插入和查找操作的时间复杂度都是O(1)，哈希表的查找速度非常快。所以在很多程序中都有使用哈希表，如拼音检查器。哈希表是基于数据的一种数据结构，数组的特点是根据下标查找时速度快，但内存扩容的成本很高，因此哈希表满时，性能下降严重。哈希表的一个重要概念是将键或关键字转换为数组下标，在哈希表中，这个过程由哈希函数完成，但有的键或关键字可以直接转换为数组的下标而不需要哈希函数。如在大学期间，每个人的学号是独特的，因此学号作为键或关键字。
STL学习_hash_table源码分析
xixihaha331的博客
06-07 1916
由于自己最近在看STL中的hash_table，被它精巧的设计所折服。无论是对桶子个数的确定，对链表的维护方式，以及判断元素在哪个桶子里等等方法都考虑到了方方面面。所以自己写了篇总结。 hash_table存储数据的特性     二叉树，AVL树，RB_tree等数据结构各有各的用途，并且具有对数平均时间，但之所以有这样高的效率取决于输入的数据有足够的随机性，那么hash_table这种数
暴力，STL，哈希技术，Floyd判圈算法（计算器谜题，uva 11549）
xl2015190026的博客
10-25 2870
想了老半天，只会暴力，然后就过了。。 实现由三种方法，一是STL，而是哈希技术，三是Floyd判圈法。 就速度而言，Floyd判圈法>哈希技术>STL。分别跑了70ms，180ms，480ms。STL真是慢的可以。 就空间而言，Floyd判圈法 也就是说，STL与哈希技术在空间和时间上各有千秋，但Floyd判圈法完爆一切= =。 关于Floyd判圈法的一些理解。 F
【C++ STL】哈希 Hash（闭散列、开散列介绍及其实现）
codewinter的博客
06-26 2822
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 O(log2N)，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个 unordered 系列的关联式容器，这4个容器与红黑树结构的关联式容器底层结构不同，是哈希表（哈希其实就是一种散列，一种映射）哈希表结构的 unordered 系列的关联式容器与红黑树结构的关联式容器 map/set/multimap/mul
【STL】哈希表 {unordered系列容器的介绍和使用；模拟实现unordered_set和unordered_map}
芥末虾的博客
09-23 494
【STL】哈希表 {unordered系列容器的介绍和使用；模拟实现unordered_set和unordered_map}
C++STL详解（七）哈希
Tau_Ceti的博客
09-17 1383
详解哈希
STL使用哈希表的容器
07-28
- *2* *3* [＜stl系列＞哈希表详解，掌握stl容器从现在开始](https://blog.csdn.net/weixin_59371851/article/details/126917526)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值