【数据结构】哈希开散列

最新推荐文章于 2021-05-22 15:46:05 发布
最新推荐文章于 2021-05-22 15:46:05 发布
阅读量246 收藏
点赞数
分类专栏： 数据结构 文章标签： 哈希 闭散列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaronlanni/article/details/80243533
版权

一、基本概念
1、哈希开散列又称为拉链法，利用链表将其出现哈希冲突的元素，全部链接在一条链上，从而更加有效的解决哈希冲突的问题。
此时可以在底层利用vector，从而实现拉链法的实现，
这里写图片描述

2、当桶中的容量<插入的元素的个数之时，则需要对当前桶进行增容，从而可以减少哈希冲突。

3、在上面的基础上，可以增加迭代器，从而实现每一个桶中元素的访问。
4、对于字符串的存储，在输出之时，因为内置类型中没有对其<<的重载，因此在此输入中将其转为可以输出的形式，利用c_str

二、哈希闭散列的实现

//hashbucket.hpp

#pragma once
#include"Common.hpp"
#include<vector>
//构造哈希桶中的结点
template<class K,class V>
struct HashBucketNode
{
    K _key;
    V _value;
    HashBucketNode<K, V>* _pNext;

    HashBucketNode(const K&key, const V&value)
        :_key(key)
        , _value(value)
        , _pNext(NULL)
    {}
};
//对哈希进行声明
template<class K, class V, class KeyToInt>
class HashBucket;

//加迭代器,对指针进行封装
template<class K, class V, class KeyToInt = KeyToIntDef<int> >
class HashBucketIterator
{
    typedef HashBucketNode<K, V> Node;
    typedef HashBucketNode<K, V>* pNode;
    typedef HashBucketIterator<K,V,KeyToInt> Self;


public:
    HashBucketIterator()
        :_pCur(NULL)
        , _ht(NULL)
    {}

    HashBucketIterator(const pNode pCur,HashBucket<K,V,KeyToInt>* ht)
        :_pCur(pCur)
        , _ht(ht)
    {}

    HashBucketIterator(Self & s)
        :_pCur(s._pCur)
        , _ht(s._ht)
    {}

    pair<K,V> operator*()
    {
        return make_pair(_pCur->_key, _pCur->_value);
    }
    pair<K, V>* operator->()
    {
        return &(operator*());
    }
    //单链表，因此没有--操作
    Self& operator++()
    {
        Next();
        return *this;
    }
    Self operator++(int)
    {
        Self tmp(*this);
        Next();
        return tmp;
    }

    bool operator!=(const Self&s)
    {
        return !(*this == s);
    }
    bool operator==(const Self&s)
    {
        return ((_pCur == s._pCur) && (_ht == s._ht));
    }
private:
    void Next()
    {
        //如果当前桶中的元素不是最后一个
        if (_pCur->_pNext)
            _pCur = _pCur->_pNext;

        //当前桶中的元素是最后一个，计算下一个桶，找下一个非空桶
        else
        {
            size_t BucketNo = _ht->Func(_pCur->_key) + 1;//计算下一个桶
            for (; BucketNo < (_ht->_hashtable.capacity()); ++BucketNo)
            {
                //当前桶如果存在
                if (_ht->_hashtable[BucketNo])
                {
                    _pCur = _ht->_hashtable[BucketNo];
                    return;
                }       
            }
            _pCur = NULL;//走到最后一个非空桶
        }
        return;
    }
public:
    pNode _pCur;
    HashBucket<K, V, KeyToInt>*  _ht;//将哈希桶中的元素引入到迭代器中，从而使得迭代器与哈希桶关联
};
//哈希桶
template<class K, class V, class KeyToInt = KeyToIntDef<int> >
class HashBucket
{
    typedef HashBucketNode<K, V> Node;
    typedef Node* pNode;

public:
    friend class HashBucketIterator<K, V, KeyToInt>;
    typedef HashBucketIterator<K, V, KeyToInt> Iterator;
public:
    //加迭代器
    Iterator Begin()//将哈希桶与迭代器相关联
    {
        //从第一个桶开始，遍历整个桶
        for (size_t BucketNo = 0; BucketNo < _hashtable.capacity(); ++BucketNo)
        {
            if (_hashtable[BucketNo])
                return Iterator(_hashtable[BucketNo], this);
        }
        return Iterator(NULL, this);//如果走出来，整个桶为空，则返回空即可。
    }

    Iterator End()
    {
        return Iterator(NULL, this);
    }

public:
    HashBucket(size_t capacity = 10)
    {
        capacity = GetNextPrime(capacity);
        _hashtable.resize(capacity);//开辟空间
        _size = 0;
    }
    //######################插入删除######################
    //唯一元素的插入
    pair<Iterator, bool> UniqueInsert(const K&key, const V&value)
    {
        CapacityCheck();
        size_t BuckNo = Func(key);//找到对应的桶
        pNode pCur = _hashtable[BuckNo];
        //创建新的结点
        pNode pNewNode = new Node(key, value);
        while (pCur)
        {
            //遍历对应桶的所有元素
            if (pCur->_key == key)
                return make_pair(Iterator(pCur, this), false);

            pCur = pCur->_pNext;
        }
        //走出来之后，没有与之相同的元素，则进行插入
        pNewNode->_pNext = _hashtable[BuckNo];
        _hashtable[BuckNo] = pNewNode;
        _size++;
        return make_pair(Iterator(pCur, this), true);
    }

    //重复性元素的插入
    pair<Iterator,bool> EqualInsert(const K&key, const V&value)
    {
        CapacityCheck();
        size_t BuckNo = Func(key);//找到对应的桶
        //创建新的结点
        pNode pNewNode = new Node(key, value);
        //插入
        pNewNode->_pNext = _hashtable[BuckNo];
        _hashtable[BuckNo] = pNewNode;
        _size++;
        return pair<Iterator, bool>(Iterator(pNewNode, this), true);//make_pair的构造函数,此处先去构造迭代器，然后才能将迭代器返回
    }

    //唯一性元素的删除
    Iterator UniqueDelete(const K&key)
    {
        size_t BuckNo = Func(key);//找到对应的桶
        pNode pCur = _hashtable[BuckNo];
        pNode Pre = NULL;
        while (pCur)
        {
            //当找到这个唯一性的元素之时，则删除
            if (pCur->_key == key)
            {
                //当待删除结点为头结点
                if (pCur == _hashtable[BuckNo])
                {
                    _hashtable[BuckNo] = pCur->_pNext;
                    delete pCur;
                    pCur = NULL;
                    _size--;
                    return Iterator(Pre, this);
                }
                else
                {
                    Pre->_pNext = pCur->_pNext;
                    delete pCur;
                    pCur = NULL;
                    _size--;
                    return Iterator(Pre, this);
                }
            }
            else
            {
                Pre = pCur;
                pCur = pCur->_pNext;
            }
        }
        return Iterator(NULL, this);
    }

    //重复性元素的删除(返回删除元素的个数）
    size_t EqualDelete(const K&key)
    {
        size_t BuckNo = Func(key);//找到对应的桶
        pNode pCur = _hashtable[BuckNo];
        pNode Pre = NULL;
        int OldSize = _size;
        while (pCur)
        {
            //当找到这个元素之时，则删除
            if (pCur->_key == key)
            {
                //当待删除结点为头结点
                if (pCur == _hashtable[BuckNo])
                {
                    _hashtable[BuckNo] = pCur->_pNext;
                    delete pCur;
                    pCur = NULL;
                    _size--;
                    pCur = _hashtable[BuckNo];
                }
                else
                {
                    Pre->_pNext = pCur->_pNext;
                    delete pCur;
                    pCur = NULL;
                    _size--;
                    pCur = Pre->_pNext;

                }
            }
            else
            {
                Pre = pCur;
                pCur = pCur->_pNext;
            }

        }
        if (OldSize == _size)
            return 0;
        else
            return OldSize - _size;
    }

    //######################查找######################
    //返回某个元素所在的桶号
    Iterator Find(const K&key)
    {
        size_t BuckNo = Func(key);//找到对应的桶
        pNode pCur = _hashtable[BuckNo];
        while (pCur)
        {
            if (pCur->_key == key)
                return Iterator(pCur, this);
            pCur = pCur->_pNext;
        }
        return Iterator(NULL, this);
    }
    const Iterator Find(const K&key)const
    {
        size_t BuckNo = Func(key);//找到对应的桶
        pNode pCur = _hashtable[BuckNo];
        while (pCur)
        {
            if (pCur->_key == key)
                return Iterator(pCur, this);
            pCur = pCur->_pNext;
        }
        return Iterator(NULL, this);
    }

    //######################其他######################
    bool Empty()const
    {
        return _size == 0;
    }


    void Clear()
    {
        size_t capacity = _hashtable.capacity();
        for (size_t BuckNo = 0; BuckNo < capacity; ++BuckNo)
        {
            pNode pCur = _hashtable[BuckNo];
            while (pCur)
            {
                //头删
                _hashtable[BuckNo] = pCur->_pNext;
                delete pCur;
                pCur = NULL;
                _size--;
                pCur = _hashtable[BuckNo];
            }
        }
    }


    //返回哈希表中指定key的元素的总个数
    size_t KeySize(const K&key)const
    {
        int count = 0;

        size_t BucketNo = Func(key);
        pNode pCur = _hashtable[BucketNo];

        while (pCur)
        {
            if (pCur->_key == key)
            {
                ++count;
            }

            pCur = pCur->_pNext;
        }
        return count;
    }
    //返回哈希表中桶的个数
    size_t BucketCount()const
    {
        return _hashtable.capacity();
    }
    //桶中元素的总个数
    size_t Size()const
    {
        return _size;
    }
    //当前桶中结点的个数
    size_t BucketSize(size_t BucketNo)
    {
        pNode pCur = _hashtable[BucketNo];
        size_t count = 0;
        while (pCur)
        {
            ++count;
            pCur = pCur->_pNext;
        }
        return count;
    }
    //找到，返回，没有找到，返回缺省值----从而封装[]
    V& FindOfInsert(const K&key)
    {
        size_t BuckNo = Func(key);//找到对应的桶
        pNode pCur = _hashtable[BuckNo];
        while (pCur)
        {
            if (pCur->_key == key)
                return pCur->_value;
            pCur = pCur->_pNext;
        }
        pair<Iterator, bool> tmp = UniqueInsert(key, V());
        return (*(tmp.first)).second;//拿出键值对，从而将其的中的value拿出来

    }
    V operator[](const K&key)
    {
        return FindOfInsert(key);
    }

    ~HashBucket()
    {
        Clear();
    }

private:
    void Swap(HashBucket<K, V,KeyToInt> ht)
    {
        swap(_hashtable, ht._hashtable);
        swap(_size, ht._size);
    }

    void CapacityCheck()
    {
        size_t capacity = _hashtable.capacity();
        if (_size == capacity)
        {
            //创建新的哈希桶
            HashBucket<K, V,KeyToInt> newHt(GetNextPrime(capacity));
            //将旧空间中的元素插入到新空间中
            for (size_t BuckNo = 0; BuckNo < capacity; ++BuckNo)
            {
                pNode pCur = _hashtable[BuckNo];
                while (pCur)
                {
                    newHt.UniqueInsert(pCur->_key, pCur->_key);
                    pCur = pCur->_pNext;
                }
            }
            Swap(newHt);
        }
    }
private:
    size_t Func(const K&key)
    {
        return KeyToInt()(key) % _hashtable.capacity();
    }
private:
    vector<pNode> _hashtable;
    size_t _size;

};

void TestBucket()
{
    HashBucket<int, int> ht;
    ht.EqualInsert(1, 1);
    ht.EqualInsert(2, 2);
    ht.EqualInsert(3, 3);
    ht.EqualInsert(4, 4);
    HashBucket<int, int >::Iterator it = ht.Begin();
    cout << ht.Size() << endl;
    HashBucket<int, int >::Iterator ret = ht.Find(3);
    cout << (*ret).first << endl;
    if (ht.Empty())
        cout << "kong" << endl;
    else
    {
        while (it != ht.End())
        {
            cout << (*it).first << " " <<it->second<<"  ";
            it++;
        }
    }

    ht.EqualDelete(1);
    cout << ht.Size() << endl;

    if (ht.Empty())
        cout << "kong" << endl;
    else
        cout << "feikong" << endl;

    ht.UniqueInsert(1, 1);
    ht.UniqueInsert(2, 2);
    ht.UniqueInsert(5, 5);
    cout << ht.Size() << endl;

    if (ht.Empty())
        cout << "kong" << endl;
    else
        cout << "feikong" << endl;
    ht.UniqueDelete(2);
    cout << ht.Size() << endl;

    if (ht.Empty())
        cout << "kong" << endl;
    else
        cout << "feikong" << endl;

    ht.Clear();
    cout << ht.Size() << endl;


    if (ht.Empty())
        cout << "kong" << endl;
    else
        cout << "feikong" << endl;
}

void Test2Bucket()
{
    HashBucket<string, string,StringToInt > ht;
    ht.EqualInsert("1111", "1111");
    ht.EqualInsert("2222", "2222");
    ht.EqualInsert("3333", "3333");
    ht.EqualInsert("你好 ", "你好");
    ht.EqualInsert("abcd", "abcd");
    //cout << ht.Find(("你好")) << endl;//有问题
    cout << ht.Size() << endl;
    if (ht.Empty())
        cout << "kong" << endl;
    else
        cout << "feikong" << endl;
    HashBucket<string, string, StringToInt>::Iterator it = ht.Begin();
    if (ht.Empty())
        cout << "kong" << endl;
    else
    {
        while (it != ht.End())
        {
            cout << (*it).first.c_str() << " " << (*it).second.c_str() << "  ";
            it++;
        }
    }
}

//comm.hpp

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<string.h>
#include<iostream>
using namespace std;
// 使用素数表对齐做哈希表的容量，降低哈希冲突
const int _PrimeSize = 28;
static const unsigned long _PrimeList[_PrimeSize] =
{
    53ul, 97ul, 193ul, 389ul, 769ul,
    1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
    49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
    1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
    50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
    1610612741ul, 3221225473ul, 4294967291ul
};
//除留余数法
size_t GetNextPrime(size_t num)
{
    for (int i = 0; i < _PrimeSize; ++i)
    {
        if (_PrimeList[i] > num)
            return _PrimeList[i];
    }

    //走到最后，仍然没有找到
    return _PrimeList[_PrimeSize - 1];
}
static size_t BKDRHash(const char * str)
{
    unsigned int seed = 131; // 31 131 1313 13131 131313
    unsigned int hash = 0;
    while (*str)
    {
        hash = hash * seed + (*str++);
    }
    return (hash & 0x7FFFFFFF);
}
//转换函数（整数）
template<class K>
class KeyToIntDef
{
public:
    size_t operator()(const K&key)
    {
        return key;
    }
};
//字符串，需要特化

class StringToInt
{
public:
    size_t operator()(const string&  key)
    {
        return BKDRHash(key.c_str()); //key.c_str()将其
    }
};

对于哈希开散列的内容，大概就是这么多，有问题，还希望大家可以指出！！！

只有不停的奔跑，才能不停留在原地！！！

梦奕
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈希——开散列
h1091068389的博客
08-06 449
又叫拉链法或者哈希桶。他先将数据按照哈希函数计算得到哈希地址，如果出现相同的哈希地址的数据，那么就用一个单链表把数据连起来，各链表的头节点存储在哈希表中。由于类似于字符串等这些不能直接使用除留余数法进行哈希函数计算哈希地址的情况，这里和闭散列里面情况类似，需要设计一些哈希方法来进行转换，从而能够进行这里的取模运算。这里的扩容是先创建一个新的vector数组，给他设置为新的大小，然后通过遍历原哈希表，将哈希表每个地址的元素，以及每个链表上面所挂的数据，一一重新映射到新的vector数组中，最后进行交换即可。.
数据结构—开散列哈希算法
一只学弱。
11-12 673
哈希表在插入和查找拥有好高的效率，当数据足够的多时，相比于平衡树，效率几乎是平衡树的两倍。 开散列哈希具有的优势就是，哈希表中存放着链表的地址，每个进来的数据通过哈希函数求得位置，存放在相应位置的链表中。查找数据时，只需要查找该数据通过哈希函数求得的位置下的链表中是否存在，就能高效的完成查找；插入时，只需要对该数据通过哈希函数求得位置的链表进行头插就可以。#include<iostream> #i
哈希---开散列
qq_44329028的博客
06-09 286
目录标题开散列开散列实现开散列扩容开散列与闭散列比较 上一篇讲解了关于哈希冲突的产生及其解决方式之一的 闭散列。 本篇主要讲解 开散列 开散列 **开散列：**开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。 从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。 开散列实现 template<class V> struct HashB
哈希之开散列
blue丶的博客
05-22 251
HashBucket.c #pragma once #include &amp;lt;assert.h&amp;gt; #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;stdlib.h&amp;gt; #include &amp;lt;malloc.h&amp;gt; //#include &quot;Common.h&quot; #define size_t uns
哈希表（开散列）
adorable_的博客
03-12 1017
开散列 开散列法又叫链地址法（开链法）。 开散列法：首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各桶中的元素通过一个单链表链接起来，个链表的头结点存储在哈希表中。
数据结构 --- 开散列处理哈希冲突（哈希桶）
y6_xiamo的博客
06-03 806
开散列 什么是开散列？ 开散列法又叫链地址法（开链法）。 首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于统一子集合，每一个子集合称为一个桶，各个桶中的元素通过单链表连接起来，各链表的头结点存储在哈希表中。 假如一个元素集合的关键码为{37，25，14，36，49，68，57，11}，散列表为HT[12],表的大小为12，散列函数为Hash(x) = x % 1...
数据结构——哈希表（散列）原理与代码应用
流楚丶格念的博客
10-24 5303
文章目录什么是哈希表？Hash的应用Hash复杂度散列表的查找步骤散列函数（哈希函数）——散列地址哈希表优缺点优点：缺点：散列的三种方法1、除法散列法2、平方散列法3、斐波那契（Fibonacci）散列法散列冲突的解决方案：扩展代码应用 什么是哈希表？ 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 记录的存储位置=f(关键
哈希（散列）查找1
08-03
哈希（散列）查找是一种高效的数据检索方法，其核心思想是通过散列函数将关键码映射到一个固定大小的散列表中，以达到快速查找的目的。在散列查找中，有两个关键问题需要解决：散列函数的设计和冲突的处理。 首先，...
数据结构课程设计 哈希散列 图形界面
03-09
在这个课程设计中，我们重点关注的是哈希散列（Hashing）这一数据结构，以及如何通过图形界面（GUI）来实现其操作。 哈希散列是一种通过哈希函数将数据映射到一个固定大小的数组的方法。这个过程通常称为哈希化，其...
数据结构之哈希表
桐花思雨
05-22 1026
目录哈希表简述几种典型数据结构特点 哈希表简述 散列表的英文名称为 hash table，因此散列表又被称为哈希表，散列函数又被称为哈希函数 散列表通常基于数组来实现。借助散列函数对数组进行扩展，利用的是数组支持按照下标随机访问元素的特性 存放数据的时候，散列函数根据 f(key) 计算出数据应该存储的位置即数组下标，从而将不同的数据分散在不同的存储位置，这也是散列的由来 查找的时候，通过散列函数 f(key) 直接确定查找 hash 值所在位置即数组下标。而不需要一个个比较，直接找到数据，提升效率 散列
哈希表--开散列【数据结构】
czf的编程工坊
03-06 393
哈希表：散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。———— 百度百科哈希冲突：对于两个数据元素的关键字Ki和Kj（i != j），有Ki  ！=  Kj，但有：  HashFun(Ki) == HashFun(...
数据结构--哈希表（散列表）
CringKong的博客
06-07 735
在学习Java集合HashMap源码时，了解到了HashMap是底层的数据结构是基于哈希表（也叫散列表），意识到以前对于哈希表的学习也是浅尝辄止的，故做了一番功课以后，写下这篇文章。 一. 定义 1.1 如何存储键值对？ 1.2 哈希算法 1.3 哈希表 1.4 哈希冲突 链地址法（Separate chaining） 开放地址法（Open addressing） 再哈希法（rehash） ...
【数据结构】简单哈希表的实现（开散列）
Qregi的博客
03-03 711
数据结构之哈希表的实现（开散列） 开散列的方法是，在哈希表中，存储一个单链表，如果出现哈希冲突，就往单链表插入 数组中每个位置存储一个单链表，我这里数组元素是指针，是不带头结点的单链表 哈希表结构体的代码如下： #define HASHMAXSIZE 1000 typedef int HashType; typedef int ValueType; type
数据结构之哈希表（散列表）
qq_44095715的博客
06-24 939
本文附带部分leetcode的例题和伪代码 哈希表 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构 也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度 采用散列技术将记录存储在一块连续的存储空间中，这块连续存储空间称为散列表或哈希表（Hash table） 哈希表hashtable(key，value) 就是把Key通过一个固定的算法函数（哈希函数）转换成一个整型数字，然后就将该数字对数组长度进行取余，取余结果就当作数组的下标，
【数据结构】—— 哈希表之开散列解决哈希冲突（哈希桶）
chenxiyuehh的博客
05-11 840
哈希的概念 ： https://blog.csdn.net/chenxiyuehh/article/details/90043229 开散列 1. 开散列概念 开散列法又叫链地址法(开链法)/哈希桶/拉链法，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。 2.开散列的实现 存...
开散列法实现哈希桶
qq_37954088的博客
04-12 379
上节我们介绍了闭散列法实现哈希表的操作，今天我们来看开散列法实现哈希桶的操作。 开散列法（链地址法(开链法)）       开散列法首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点组成 一个向量，因此，向量的元素个数与可能的桶数一致。 设元素的关键码为37,25,14,36,49,68,5...
数据结构---哈希表的C语言实现
热门推荐
啦~啦~啦~的博客
03-06 4万+
构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。 说到哈希表，，首先就得说到哈希函数，哈希函数是用来得到给定key值的在哈希表中的存储位置的。 哈希函数也并不是固定的，可以自己根据情况来定，一般常用常见的有直接定制法，除留余数法，平方取中法，折叠法，随机数法，数学分析法。 当...
开散列哈希
d_CSDNW的博客
04-06 164
Common.h #pragma once // 使用素数表对齐做哈希表的容量，降低哈希冲突unsigned long GetNextPrime(unsigned long num);Common.c #include "Common.h" #define _PrimeSize 28 unsigned long _PrimeList[_PrimeSize] = { 53ul, 97ul, 1
数据结构--搜索结构之哈希二( 开散列 拉链法) ( c语言版 )
【Dyson】的博客
09-04 1271
开散列: 开散列法又叫链地址法(开链法) , 哈希桶 开散列法：首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。 设元素的关键码为37, 25, 14, 36, 49, 68, 57, 11, 散列表为HT[11]，表的大小为11，散列函数为Hash(x) = x % 11 ...
解决哈希冲突的开散列方法
最新发布
05-23
开散列的基本思想是将哈希表中的每个位置都指向一个链表或者其他数据结构，如果发生哈希冲突，就将冲突的元素加入到对应位置的链表中。 开散列的实现过程如下： 1. 创建一个大小为n的数组，每个元素都是一个链表头...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值