微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

《数据结构》学习-- Hash(2) --Separate Chaining

分类：数据结构作者：编程之家

本系列是《数据结构与算法分析-C语言描述》（Data Structures and Algorithm Analysis in C，作者Mark Weiss）一书的学习笔记，当我在做cc150需要补某个知识点时，就会把这本书翻出来学习一下，同时分享~

如果你有任何问题和建议，希望能与我分享.

1. 回顾

上一次我们简单介绍了：

  1. Hash表的概念
    由输入数据的数据结构构成的Array
  2. 优缺点
    查找、插入、删除平均常数时间。但不维护Array的顺序。
  3. 四大要素
    Hash表主体，Hash表大小，Hash Function，冲突解决方案。

实际上，Hash表最难设计的就是Hash Function以及冲突解决方法（Collision Resolution）。关于Hash Function的设计，没有一个统一的方法，常用的方法我们也在第一章介绍过了。
这一章，我们将介绍一种常用的冲突解决方案，即开散列法（Separate Chaining）。

2. Separate Chaining简介

Separate Chaining的思想无比简单。即原本Hash表每个元素是一个输入数据的数据结构类型，现在把每个元素改成一个由该数据结构类型构成的指针链表。这样，当发生冲突时，只要在该指针链表的尾端或首端插入该值即可。

3.Rehash

在详述我们的HashTable实现之前，我们还要引入最后一个概念：rehash。当我们不断往HashTable内插入元素，HashTable就会越来越满，而Find，Insert，Remove的操作都会越来越慢！
事实上，我们定义一个负重参数（load factor） λ ，它的值是HashTable已有的元素数除以HashTable表大小。对于每一次不成功的搜索，平均搜索次数为 λ （不包括最后的NULL），对于每一次成功的搜索，平均搜索次数为 1+λ/2 。因此，HashTable本身的大小对性能的影响并不大，重要的是load factor的大小。Mark Weiss建议，general rule是保证 λ 尽可能接近1。
因此，当我们的load factor比较大时，我们需要扩充HashTable，以让load factor尽可能接近1，这个过程就是rehash。另一方面，rehash是非常耗时的工作，因为我们需要遍历所有元素，然后全部重新插入一遍，因此，只有当必须（即load factor大到某一阈值时）时才去执行。

3. Separate Chaining实现

接下来使用C++代码详解Separate Chaining的实现。该代码在Mac OS X 64bit系统，clang++编译器下调试通过，其他平台不能保证。想直接下载文件可以戳[这里]。

3.1 Hash表主体

struct HashNode{
            ElementType elementValue;
            HashNode* next;
        };
        typedef HashNode* HashList;
        struct HashTbl{
            HashList* table;
            int tableSize;
            int content;
        };
        HashTbl* hashTable;

不知道为何CSDN的Markdown对混合了大段注释语句的高亮支持很不好，我把注释放在下面，已经清楚解释了这个代码的功能。

/*our hash table is actually a link to a struct called HashTbl,* the HashTbl consists of a array of HashList,which is a linked list of HashNode
             * and a tableSize,indicating how large is our hash table
             * and a content,indicating how full is our hash table
             * the HashNode is just a node in a linked list,consisting of the content(elementValue) and a linked to next node
             */

3.2 初始化操作

初始化操作很简单，不断把内存空间分配就好了。
注意，我这里在new以后，做了判断NULL的步骤，不过根据StackOverflow讨论，这种分配方式在内存分配失败后是会返回bad_alloc标志，因此应该用try catch来处理，而不是判断NULL。另外，文中也建议使用STL库而不是手动分配内存来管理动态数据。我还在学习中，以后进一步完善。

template<class ElementType>
void HashTable<ElementType>::initialize(HashTbl*& newHashTable,int minSize)
{
    newHashTable=new HashTbl;
    if(newHashTable==NULL){
        printf("new operation Failed! At file: %s,line: %d\n",__FILE__,__LINE__);
        exit(-1);
    }

    //寻找比minSize大的最近的质数。因为质数大小的Hash表性能最好。minSize是用户一开始指定的Hash表大小。
    int tableSize=nextPrime(minSize);

    newHashTable->table=new HashList[tableSize];
    if(newHashTable->table==NULL){
        printf("new operation Failed! At file: %s,__LINE__);
        exit(-1);
    }

    for(int i=0;i<tableSize;i++){
        newHashTable->table[i]=new HashNode;
        if(newHashTable->table[i]==NULL){
            printf("new operation Failed! At file: %s,__LINE__);
            exit(-1);
        }
        newHashTable->table[i]->next=NULL;
    }

    newHashTable->tableSize=tableSize;
    newHashTable->content=0;
}

值得注意的一点是，这里函数声明时，第一个参数是HashTbl*&,即一个指向指针的引用。这样做的目的是，之后我们传递实际的HashTable指针进来时，可以在函数内部修改这个指针。可以参考这个文章。

3.3 Hash Function

template<class ElementType>
int HashTable<ElementType>::hashFunc(ElementType elementValue)
{
    //getElementKey是根据输入数据的数据结构来获得数据Key的函数。如果数据数据是整数，那么Key可以就等于输入数据。如果输入数据是字符串，那么Key可以等于所有字符对应ASCII码之和。等等。
    int key=getElementKey(elementValue);
    return key%(hashTable->tableSize);//using simple module method to get new position
}

3.4 Find

template<class ElementType>
class HashTable<ElementType>::HashNode* HashTable<ElementType>::findInner(HashTbl* _hashTable,ElementType elementValue)
{
    int position=hashFunc(_hashTable,elementValue);
    HashNode* hashNode=_hashTable->table[position];
    while(hashNode->next!=NULL && !isEqual(hashNode->next->elementValue,elementValue)){
        hashNode=hashNode->next;
    }
    return hashNode;
}

template<class ElementType>
bool HashTable<ElementType>::find(ElementType elementValue)
{
    HashNode* hashNode = findInner(hashTable,elementValue);
    return hashNode->next != NULL;
}

这个函数总体是很容易看懂的（前提是你得懂类模板哈哈，不懂的话可以参考：类模板基础 和 类模板中的结构体）
至于为什么需要一个findInner和一个find呢？find函数是给用户用的，用户只需要简单的传递一个elementValue就能知道find是否成功。而findInner是给HashTable内部实现用的。
另外，这里的isEqual函数是用户自己定义的，因为不同的数据结构判断相等的标准不一样（如int直接等于即可，而string需要用strcmp）。

3.5 Insert

template<class ElementType>
bool HashTable<ElementType>::insertInner(HashTbl*& _hashTable,ElementType elementValue)
{
    //rehash
    if(_hashTable->content>_hashTable->tableSize*10)
    {
        _hashTable=rehash();
    }

    HashNode* insertNode=findInner(_hashTable,elementValue);
    if(insertNode->next==NULL){
        insertNode->next=new HashNode;
        if(insertNode->next==NULL){
            printf("new operation Failed! At file: %s,__FILE__,__LINE__);
            exit(-1);
        }

        insertNode->next->elementValue=elementValue;
        insertNode->next->next=NULL;
        _hashTable->content++;
        return true;
    }
    return false;
}

template<class ElementType>
bool HashTable<ElementType>::insert(ElementType elementValue)
{
    return insertInner(hashTable,elementValue);
}

同样，这段代码也很容易理解。rehash函数的实现见下面。

3.6 Remove

template<class ElementType>
bool HashTable<ElementType>::removeInner(HashTbl* _hashTable,ElementType elementValue)
{
    HashNode* removeNode=findInner(_hashTable,elementValue);
    if(removeNode->next !=NULL){
        HashNode* tobedelete=removeNode->next;
        removeNode->next=removeNode->next->next;
        delete tobedelete;
        _hashTable->content--;
        return true;
    }
    return false;
}

template<class ElementType>
bool HashTable<ElementType>::remove(ElementType elementValue)
{
    return removeInner(hashTable,elementValue);
}

同样比较清楚。

3.7 rehash

template<class ElementType>
class HashTable<ElementType>::HashTbl* HashTable<ElementType>::rehash()
{
    HashTbl* newTable;
    initialize(newTable,hashTable->tableSize*10);

    for(int i=0;i<hashTable->tableSize;i++){
        HashNode* hashNode=hashTable->table[i]->next;
        while(hashNode){
            insertInner(newTable,hashNode->elementValue);
            hashNode=hashNode->next;
        }
    }
    delete hashTable;
    return newTable;
}

rehash函数非常简单，创建一个两倍于原来大小的新HashTable，然后把之前每个HashNode重新插入到新的HashTable中。
另外，这里我设定当load factor为10时，我们把HashTable扩充到原来的10倍。这个10是我随意设定的，没有进行过性能优化。

3.8 nextPrime

template<class ElementType>
bool HashTable<ElementType>::isPrime(int num)
{
    bool result;
    if(num==2)
        result=true;
    else if(num/2*2 == num)
        result=false;
    else{
        int sqrtNum=sqrt(num);
        result=true;
        for(int i=3;i<sqrtNum;i+=2){
            if(num/i*i==num){
                result=false;
                break;
            }
        }
    }
    return result;
}

template<class ElementType>
int HashTable<ElementType>::nextPrime(int num)
{
    int result=num+1;
    while(!isPrime(result))
        result++;
    printf("result:%d\n",result);
    return result;
}

寻找下一个质数。

4. HashTable测试

我们首先定义好使用的输入数据的数据结构，getElementKey函数以及isEqual函数。在这里，我们用最简单的int做测试。

typedef int ElementType;

int getElementKey(ElementType elementValue){
    return elementValue;
}

bool isEqual(ElementType elementValue1,ElementType elementValue2){
    return elementValue1==elementValue2;
}

4.1正确性测试

为了测试我们的HashTable是否正确。我们在一个循环中，插入循环index，然后搜索这个index，确保每一次都能搜索到。然后在一个循环中，删除index，然后搜索这个index，确保每一次都搜索不到。

bool testHashCorrectness(HashTable<ElementType> &hashTable)
{
    int checkTotal=10000000;
    for(int i=0;i<checkTotal;i++){
        hashTable.insert(i);
        if(!hashTable.find(i))
            return false;
    }
    for(int i=0;i<checkTotal;i++){
        hashTable.remove(i);
        if(hashTable.find(i))
            return false;
    }
    return true;
}

int main()
{
    HashTable<int> hashTable(100000,&getElementKey,&isEqual);
    printf("check correctness: %d\n",testHashCorrectness(hashTable));
    return 0;
}

结果为：

check correctness: 1

4.2 性能测试

最后，我们对于使用或不使用rehash函数来做一个性能测试。

int main()
{
    HashTable<int> hashTable(100000,&isEqual);

    clock_t start=clock();
    for(int i=0;i<10000000;i++){
        int r=rand();
        hashTable.insert(r);
    }
    clock_t finish=clock();
    printf("time is %fs\n",(double)(finish-start)/CLOCKS_PER_SEC);

    return 0;
}

当我们不适用rehash函数，测试结果为：

time is 47.611208s

而使用了rehash函数之后，测试结果为：

time is 8.676079s

相信细调load factor之后，性能可以有更大的提升。

5. 总结

这一章我们介绍了HashTable中的Separate Chaining解决Collision的方法。其核心思想就是用一个链表结构替代原先最简单的HashTable中的每一个元素。 另外我们还介绍了rehash函数，并引入了load factor概念。 Separate Chaining的优点在于其实现非常简单。并且能非常好的解决冲突问题。 Separate Chaining的缺点在于，每次插入一个元素都需要new一个内存空间，这个操作涉及到核心函数，所以速度会慢。 如何解决这个问题呢？请期待下一篇“《数据结构》学习–Hash（3）–Open Addressing”！

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

【啊哈！算法】算法3：最常用的排序——快速排序
【啊哈！算法】算法3：最常用的排序——快速排序       上一节的冒泡排序可以说是我们学习第一个真正的排序算法，并且解决了桶排序浪费空间的问题，但在算法的执行效率上却牺牲了很多，它的时间复杂度达到了O(N2)。假如我们的计算机每秒钟可以运行10亿次，那么对1亿个数进行排序，桶排序则只需要0.1秒，而冒泡排序则需要1千万秒，达到115天之久，是不是很吓人。那有没有既不浪费空间又可以快一点的排序算法
[数据结构与算法]模式匹配与文本处理-匿名组与命名组
匿名组 这里可能用到几个不同的分组构造。通过括号内围绕的正则表达式就可以组成第一个构造。正如稍后要介绍的一样，既然也可以命名组，大家就有考虑把这个构造作为匿名组。作为一个实例，请看看下列字符串： “08/14/57 46 02/25/59 45 06/05/85 18 03/12/88 16 09/09/90 13“ 这个字符串就是由生日和年龄组成的。如果需要匹配年两而不要生日，就可以把正则
[C#]选择排序
选择排序：从数组的起始位置处开始，把第一个元素与数组中其他元素进行比较。然后，将最小的元素方式在第0个位置上，接着再从第1个位置开始再次进行排序操作。这种操作一直到除最后一个元素外的每一个元素都作为新循环的起始点操作过后才终止。 public void SelectionSort() { int min, temp;
[数据结构与算法]队列的优先级
public struct Pqitem { public int priority; public string name; } class CQueue { private ArrayList pqueue; public CQueue() { pqueue
[数据结构与算法]模式匹配-数量词
在编写正则表达式的时候，经常会向要向正则表达式添加数量型数据，诸如”精确匹配两次”或者”匹配一次或多次”。利用数量词就可以把这些数据添加到正则表达式里面了。 数量词(+):这个数量词说明正则表达式应该匹配一个或多个紧紧接其前的字符。 string[] words = new string[] { "bad", "boy", "baad", "baaad" ,"bear", "b
[数据结构与算法]白话经典算法系列之五 归并排序的实现
来自：http://blog.csdn.net/morewindows/article/details/6678165/归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列
[C#]插入排序
插入排序算法有两层循环。外层循环会啄个遍历数组元素，而内存循环则会把外层循环所选择的元素与该元素在数组内的下一个元素进行比较。如果外层循环选择的元素小于内存循环选择的元素，那么瘦元素都想右移动以便为内存循环元素留出位置。 public void InsertionSort() { int inner, temp;
[C#]二叉查找法
public int binSearch(int value) { int upperBround, lowerBound, mid; upperBround = arr.Length - 1; lowerBound = 0; while (lowerBound <= upper
[数据结构与算法]双向链表
虽然从表内第一个节点到最后一个节点的遍历操作是非常简单的，但是反向遍历链表却不是一件容易的事情。如果为Node类添加一个字段来存储指向前一个节点的连接，那么久会使得这个反向操作过程变得容易许多。当向链表插入节点的时候，为了吧数据复制给新的字段会需要执行更多的操作，但是当腰吧节点从表移除的时候就能看到他的改进效果了。 首先需要修改Node类来为累增加一个额外的链接。为了区别两个连接，这个把指
[数据结构]树及树的遍历
八、树（Tree）树，顾名思义，长得像一棵树，不过通常我们画成一棵倒过来的树，根在上，叶在下。不说那么多了，图一看就懂：当然了，引入了树之后，就不得不引入树的一些概念，这些概念我照样尽量用图，谁会记那么多文字？树这种结构还可以表示成下面这种方式，可见树用来描述包含关系是很不错的，但这种包含关系不得出现交叉重叠区域，否则就不能用树描述了，看图：面试的时候我们经常被考到的是一种叫“二叉树”的结构，二叉
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot