多核计算与程序设计 - 06 基本算法和数据结构 之三 哈希表与哈希链表

最新推荐文章于 2023-11-27 13:09:31 发布
最新推荐文章于 2023-11-27 13:09:31 发布
阅读量973 收藏 2
点赞数 1
分类专栏： 多线程与并行程序设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangzhiyu1980/article/details/8458553
版权
本文介绍了哈希表的索引方法，如整除取余法、折叠法、平方取中法和随机函数法，以及解决哈希冲突的链表存储法、索引探测法。通过示例展示了插入和查找操作，讨论了哈希链表如何结合哈希表和链表的优点。
摘要由CSDN通过智能技术生成

一，哈希表

哈希表：hash(杂乱信息的意思)  的音译，用来把一些杂乱无章的信息根据其关键字的特点映射到一个连续的空间，操作简单，用途广泛，例如：电子词典。

这里用到的映射方法称为 索引方法。对应的实现函数称为哈希函数。将映射后的值称为索引。


1） 哈希表的索引方法

整除取余法

对于整数而言，是很常用的一个方法，能够很快的计算出索引值，但有时候会产生较多的相同的索引，使算法退化。

最差的时候会变成顺序查找。

int hashInt1(int nKey, int uBucketCount)
{
    return nKey % uBucketCount;
}

// 一种优化的方式
// 把 uBucketCount 定义为1024, 2048 ... 2的幂
// uMask 的值为 uBucketCount - 1， 这样uMask的二进制值全部为 '1'
// 用key 和 uMask 进行与运算。
int hashInt2(int nKey, int uMask)
{
    return nKey & uMask;
}


折叠法

当关键词位数很长时，可以将关键字分割成位数相同的几部分，把每部分转换成计算机可以识别的整数，再将整数相加，得到新的整数，再把得到的新的整数用上面的取余法进行运算，得到hash值。


int hashString(char* strKey, int uBucketCount)
{
    int i = 0;
    int nRet = 0;
    int nHashValue = 0;
    char* p = strKey;
    
    while(*p != '\0')
    {
    <span style="white-space:pre">	</span><span style="color:#ff0000;">// 这里把字符串分组，并把每组转换为一个整数
    <span style="white-space:pre">	</span>// 这个转换方法可以自己定义，按照key的特征灵活选择</span>
        if (i == 5)
        {
            i = 0;
            nRet += nHashValue;
            nHashValue = 0;
        }


    <span style="white-space:pre">	</span>nHashValue += nHashValue << 3;
    <span style="white-space:pre">	</span>nHashValue += (int)(*p);
    <span style="white-space:pre">	</span>p++;
    <span style="white-space:pre">	</span>i++;
    }


    nRet += nHashValue;
<span style="white-space:pre">	</span>return nRet % uBucketCount;
}


平方取中法

将关键字进行平方运算后，再取中间几位作为索引。


//<span style="color:#ff0000;"> 例：平方后取234位(个位为第0位)作为hash值</span>
int hashSqrMid234(int nKey)
{
    int nRet =0;
    int nHashValue = 0;
	nHashValue = nKey * nKey;
	
	nRet = nHashValue / 100000;
	nHashValue = nHashValue /100;
	
	nRet = nHashValue % (nRet * 1000);
	return nRet;
}


随即函数法

用随机函数产生hash值。



2） 哈希表的冲突解决方法

不同的关键字，通过hash算法可能得到相同的hash值，这就产生了冲突。


解决冲突的方法：

链表存储法

将同一索引的关键词放在一个链表中，将哈希表的索引指向链表的表头。


索引探测法

索引探测法的基本思想是发现索引有冲突后，在索引的位置向后查找一个空的索引位置，将数据存放在此索引的位置。

索引探测法公式描述：


      H(i)   =  ( Hash ( key )  +  P(i) )  %  uBucketCount


线性探测法：

当发现索引处已经存储数据时，从索引位置向后按顺序查找一个空索引的位置，将数据存储在这个空位置上。

P(i) = 1


二次探测法 和伪随机探测法：

P(i) = i * i 时 为二次探测法

P(i) = 随机序列时 为伪随机探测法


实例代码：

hash_table.h

#include <iostream>

using namespace std;

#ifndef __HASH_TABLE_H__
#define __HASH_TABLE_H__

typedef struct _SINGLE_NODE
{
    int  nData;
    _SINGLE_NODE *pNext;
}SINGLE_NODE;


class MyHashTable
{
public:
	MyHashTable();
	~MyHashTable();

    int  InsertHashTable(int nData);
    int  FindHash(int nData);
    void DeleteHash(int nData);

private:

    SINGLE_NODE ** m_pBucket;
	int            m_nBucketCount;
	int            m_nNodeCount;
	int            m_nCurrNodeID;
    SINGLE_NODE  * m_pCurrentNode;

	int calcHash(int nKey);
};

#endif


hash_table.cpp

#include "hash_table.h"

int hashInt1(int nKey, int uBucketCount)
{
    return nKey % uBucketCount;
}

// 一种优化的方式
// 把 uBucketCount 定义为1024, 2048 ... 2的幂
// uMask 的值为 uBucketCount - 1， 这样uMask的二进制值全部为 '1'
// 用key 和 uMask 进行与运算。
int hashInt2(int nKey, int uMask)
{
    return nKey & uMask;
}


int hashString(char* strKey, int uBucketCount)
{
    int i = 0;
    int nRet = 0;
    int nHashValue = 0;
    char* p = strKey;
    
    while(*p != '\0')
    {
    	// 这里把字符串分组，并把每组转换为一个整数
    	// 这个转换方法可以自己定义，按照key的特征灵活选择
        if (i == 5)
        {
            i = 0;
            nRet += nHashValue;
            nHashValue = 0;
        }

    	nHashValue += nHashValue << 3;
    	nHashValue += (int)(*p);
    	p++;
    	i++;
    }

    nRet += nHashValue;
	return nRet % uBucketCount;
}

int hashSqrMid234(int nKey)
{
    int nRet =0;
    int nHashValue = 0;
	nHashValue = nKey * nKey;  // 5499025
	
	nRet = nHashValue / 100000;   // 549
	nHashValue = nHashValue /100;   // 54990
	
	nRet = nHashValue % (nRet * 1000);
	return nRet;
}

MyHashTable::MyHashTable()
{
    m_nBucketCount = 1024;
    m_nNodeCount = 0;
	m_nCurrNodeID = 0;
    m_pCurrentNode = NULL;

	m_pBucket = (SINGLE_NODE**)malloc(m_nBucketCount * sizeof(SINGLE_NODE*));
	memset(m_pBucket, 0, m_nBucketCount * sizeof(SINGLE_NODE*));
}

MyHashTable::~MyHashTable()
{
    SINGLE_NODE *pNode = NULL;

    for (int i = 0 ; i < m_nBucketCount; i++)
	{
	    pNode = m_pBucket[i];
		while (pNode != NULL)
		{
		    m_pBucket[i] = pNode->pNext;
            free(pNode);
			pNode = NULL;
			pNode = m_pBucket[i];

		}
	}
}

int MyHashTable::calcHash(int nKey)
{
    return hashInt1(nKey, m_nBucketCount);
}


int MyHashTable::InsertHashTable(int nData)
{
    SINGLE_NODE *pNode = NULL;
    SINGLE_NODE *pNewNode;
	int nHashValue;

    pNewNode = (SINGLE_NODE*)malloc(sizeof(SINGLE_NODE));

    nHashValue = calcHash(nData);
	pNode = m_pBucket[nHashValue];

	cout << "Insert Hash Key: " << nHashValue  << "  Value=" << nData << endl;

	pNewNode->nData = nData;
	pNewNode->pNext = pNode;

    m_pBucket[nHashValue] = pNewNode;
    m_nNodeCount += 1;

	return m_nNodeCount;
}

int MyHashTable::FindHash(int nData)
{
    SINGLE_NODE *pNode;
	int nHashValue;

    nHashValue = calcHash(nData);
	pNode = m_pBucket[nHashValue];

    while(pNode != NULL)
	{
	    if (pNode->nData == nData)
		{
			cout << "FindHash find it Key= " <<nHashValue << " Data=" << pNode->nData << endl;
		    return pNode->nData;
		}
		pNode = pNode->pNext;
	}

	return -1;
}

void MyHashTable::DeleteHash(int nData)
{
    SINGLE_NODE *pNode;
	int nHashValue;

    nHashValue = calcHash(nData);
	pNode = m_pBucket[nHashValue];

    if (pNode != NULL)
	{
	    m_pBucket[nHashValue] = pNode->pNext;
		free(pNode);
		pNode = NULL;
	}
}

main.cpp  测试程序 

#include "hash_table.h"

void main()
{
	int testArr[10] = {123, 4332,223,8664,2239,89777,54455,32,23,64322};
    int i = 0;

    MyHashTable hashTable;

	for (i = 0; i < 10; i++)
	{
	    hashTable.InsertHashTable(testArr[i]);
	}


    cout << endl;
	cout << "Finding the hash kes and values" << endl;
	cout << endl;
    for (i = 0; i < 10; i++)
	{
	    if (hashTable.FindHash(testArr[i]) != -1)
		{
		    cout << "========================" << endl;
		}
	}

	hashTable.DeleteHash(testArr[3]);

   cout << endl;
	cout << "Test the 3 the key is deleted" << endl;
	cout << endl;
    for (i = 0; i < 10; i++)
	{
	    if (hashTable.FindHash(testArr[i]) != -1)
		{
		    cout << "========================" << endl;
		}
	}
    cin >> i;

}

测试结果：

Insert Hash Key: 123  Value=123
Insert Hash Key: 236  Value=4332
Insert Hash Key: 223  Value=223
Insert Hash Key: 472  Value=8664
Insert Hash Key: 191  Value=2239
Insert Hash Key: 689  Value=89777
Insert Hash Key: 183  Value=54455
Insert Hash Key: 32  Value=32
Insert Hash Key: 23  Value=23
Insert Hash Key: 834  Value=64322


Finding the hash kes and values


FindHash find it Key= 123 Data=123
========================
FindHash find it Key= 236 Data=4332
========================
FindHash find it Key= 223 Data=223
========================
FindHash find it Key= 472 Data=8664
========================
FindHash find it Key= 191 Data=2239
========================
FindHash find it Key= 689 Data=89777
========================
FindHash find it Key= 183 Data=54455
========================
FindHash find it Key= 32 Data=32
========================
FindHash find it Key= 23 Data=23
========================
FindHash find it Key= 834 Data=64322
========================


Test the 3 the key is deleted


FindHash find it Key= 123 Data=123
========================
FindHash find it Key= 236 Data=4332
========================
FindHash find it Key= 223 Data=223
========================
FindHash find it Key= 191 Data=2239
========================
FindHash find it Key= 689 Data=89777
========================
FindHash find it Key= 183 Data=54455
========================
FindHash find it Key= 32 Data=32
========================
FindHash find it Key= 23 Data=23
========================
FindHash find it Key= 834 Data=64322
========================


二，哈希链表

哈希表可以实现快速的精确查找，但无法实现排序操作，链表可以实现有序的输出，但在查找时时间较长，为了结合哈希表和链表的优点这里实现了一个哈希链表。

哈希链表的数据结构是结合了链表和哈希表的复合数据结构。


实例代码：


hash_link_table.h

#include <iostream>

using namespace std;

#ifndef __HASH_LINK_TABLE_H__
#define __HASH_LINK_TABLE_H__



typedef struct _SINGLE_NODE
{
    int  nData;
    _SINGLE_NODE *pHashNext;
    _SINGLE_NODE *pPrev;
    _SINGLE_NODE *pNext;
}SINGLE_NODE;


class MyHashTable
{
public:
    MyHashTable();
    ~MyHashTable();

    int  InsertHashTable(int nData);
    int  FindHash(int nData);
    void DeleteHash(int nData);
    void ShowSortLink();

private:

    SINGLE_NODE ** m_pBucket;
    int            m_nBucketCount;
    int            m_nNodeCount;
    int            m_nCurrNodeID;
    SINGLE_NODE  * m_pCurrentNode;
    SINGLE_NODE  * m_pLinkHead;
    SINGLE_NODE  * m_pLinkTail;

    int calcHash(int nKey);
};

#endif

hash_link_table.cpp 

#include "hash_link_table.h"

int hashInt1(int nKey, int uBucketCount)
{
    return nKey % uBucketCount;
}

// 一种优化的方式
// 把 uBucketCount 定义为1024, 2048 ... 2的幂
// uMask 的值为 uBucketCount - 1， 这样uMask的二进制值全部为 '1'
// 用key 和 uMask 进行与运算。
int hashInt2(int nKey, int uMask)
{
    return nKey & uMask;
}


int hashString(char* strKey, int uBucketCount)
{
    int i = 0;
    int nRet = 0;
    int nHashValue = 0;
    char* p = strKey;

    while(*p != '\0')
    {
        // 这里把字符串分组，并把每组转换为一个整数
        // 这个转换方法可以自己定义，按照key的特征灵活选择
        if (i == 5)
        {
            i = 0;
            nRet += nHashValue;
            nHashValue = 0;
        }

        nHashValue += nHashValue << 3;
        nHashValue += (int)(*p);
        p++;
        i++;
    }

    nRet += nHashValue;
    return nRet % uBucketCount;
}

int hashSqrMid234(int nKey)
{
    int nRet =0;
    int nHashValue = 0;
    nHashValue = nKey * nKey;  // 5499025

    nRet = nHashValue / 100000;   // 549
    nHashValue = nHashValue /100;   // 54990

    nRet = nHashValue % (nRet * 1000);
    return nRet;
}

MyHashTable::MyHashTable()
{
    m_nBucketCount = 1024;
    m_nNodeCount = 0;
    m_nCurrNodeID = 0;
    m_pCurrentNode = NULL;
    m_pLinkHead = NULL;
    m_pLinkTail = NULL;

    m_pBucket = (SINGLE_NODE**)malloc(m_nBucketCount * sizeof(SINGLE_NODE*));
    memset(m_pBucket, 0, m_nBucketCount * sizeof(SINGLE_NODE*));
}

MyHashTable::~MyHashTable()
{
    SINGLE_NODE *pNode = NULL;

    for (int i = 0 ; i < m_nBucketCount; i++)
    {
        pNode = m_pBucket[i];
        while (pNode != NULL)
        {
            m_pBucket[i] = pNode->pNext;
            free(pNode);
            pNode = NULL;
            pNode = m_pBucket[i];

        }
    }
}

int MyHashTable::calcHash(int nKey)
{
    return hashInt1(nKey, m_nBucketCount);
}


int MyHashTable::InsertHashTable(int nData)
{
    SINGLE_NODE *pNode = NULL;
    SINGLE_NODE *pNewNode;
    int nHashValue;

    pNewNode = (SINGLE_NODE*)malloc(sizeof(SINGLE_NODE));

    nHashValue = calcHash(nData);
    pNode = m_pBucket[nHashValue];

    cout << "Insert Hash Key: " << nHashValue  << "  Value=" << nData << endl;

    pNewNode->nData = nData;
    pNewNode->pHashNext = pNode;

    m_pBucket[nHashValue] = pNewNode;
    m_nNodeCount += 1;


    // add to link
    pNewNode->pNext = NULL;
    pNewNode->pPrev = NULL;
    if (m_pLinkHead == NULL)
    {
        m_pLinkHead = pNewNode;
        m_pLinkTail = pNewNode;
    }
    else
    {
        pNode = m_pLinkHead;
        while ((pNode->pNext != NULL) && (pNewNode->nData > pNode->nData))
        {
            pNode = pNode->pNext;
        }

        if ((pNode->pNext == NULL) && (pNewNode->nData >  pNode->nData))
        {
            pNewNode->pPrev = pNode;
            pNode->pNext = pNewNode;
            m_pLinkTail = pNewNode;
        }
        else
        {
            pNewNode->pPrev = pNode->pPrev;
            if (pNode != m_pLinkHead)
            {
                pNode->pPrev->pNext = pNewNode;
            }
            else
            {
                m_pLinkHead = pNewNode;
            }

            pNewNode->pNext = pNode;
            pNode->pPrev = pNewNode;
        }
    }

    return m_nNodeCount;
}

void MyHashTable::ShowSortLink()
{
    SINGLE_NODE *pNode = m_pLinkHead;
    cout << endl;
    cout << endl;
    cout << "Show all the node ==========================" << endl;
    while(pNode != NULL)
    {
        cout << "key= " << pNode->nData << "   ";
        pNode = pNode->pNext;
    }
    cout << endl;
    cout << endl;
}

int MyHashTable::FindHash(int nData)
{
    SINGLE_NODE *pNode;
    int nHashValue;

    nHashValue = calcHash(nData);
    pNode = m_pBucket[nHashValue];

    while(pNode != NULL)
    {
        if (pNode->nData == nData)
        {
            cout << "FindHash find it Key= " <<nHashValue << " Data=" << pNode->nData << endl;
            return pNode->nData;
        }
        pNode = pNode->pNext;
    }

    return -1;
}

void MyHashTable::DeleteHash(int nData)
{
    SINGLE_NODE *pNode;
    int nHashValue;

    nHashValue = calcHash(nData);
    pNode = m_pBucket[nHashValue];

    if (pNode != NULL)
    {
        m_pBucket[nHashValue] = pNode->pNext;
        pNode->pPrev->pNext = pNode->pNext;
        pNode->pNext->pPrev = pNode->pPrev;

        free(pNode);
        pNode = NULL;
    }
}

main.cpp 

#include "hash_link_table.h"

void main()
{
    int testArr[10] = {123, 4332,223,8664,2239,89777,54455,32,23,64322};
    int i = 0;

    MyHashTable hashTable;

    for (i = 0; i < 10; i++)
    {
        hashTable.InsertHashTable(testArr[i]);
    }


    cout << endl;
    cout << "Finding the hash kes and values" << endl;
    cout << endl;
    for (i = 0; i < 10; i++)
    {
        if (hashTable.FindHash(testArr[i]) != -1)
        {
            cout << "========================" << endl;
        }
    }

    hashTable.ShowSortLink();

    hashTable.DeleteHash(testArr[3]);

    cout << endl;
    cout << "Test the 3 the key is deleted" << endl;
    cout << endl;
    for (i = 0; i < 10; i++)
    {
        if (hashTable.FindHash(testArr[i]) != -1)
        {
            cout << "========================" << endl;
        }
    }

    hashTable.ShowSortLink();
    cin >> i;
}


测试结果：

Insert Hash Key: 123  Value=123
Insert Hash Key: 236  Value=4332
Insert Hash Key: 223  Value=223
Insert Hash Key: 472  Value=8664
Insert Hash Key: 191  Value=2239
Insert Hash Key: 689  Value=89777
Insert Hash Key: 183  Value=54455
Insert Hash Key: 32  Value=32
Insert Hash Key: 23  Value=23
Insert Hash Key: 834  Value=64322


Finding the hash kes and values


FindHash find it Key= 123 Data=123
========================
FindHash find it Key= 236 Data=4332
========================
FindHash find it Key= 223 Data=223
========================
FindHash find it Key= 472 Data=8664  test deleting
========================
FindHash find it Key= 191 Data=2239
========================
FindHash find it Key= 689 Data=89777
========================
FindHash find it Key= 183 Data=54455
========================
FindHash find it Key= 32 Data=32
========================
FindHash find it Key= 23 Data=23
========================
FindHash find it Key= 834 Data=64322
========================




Show all the node ==========================
key= 23   key= 32   key= 123   key= 223   key= 2239   key= 4332   key= 8664   key= 54455   key= 64322   key= 89777




Test the 3 the key is deleted


FindHash find it Key= 123 Data=123
========================
FindHash find it Key= 236 Data=4332
========================
FindHash find it Key= 223 Data=223
========================
FindHash find it Key= 191 Data=2239
========================
FindHash find it Key= 689 Data=89777
========================
FindHash find it Key= 183 Data=54455
========================
FindHash find it Key= 32 Data=32
========================
FindHash find it Key= 23 Data=23
========================
FindHash find it Key= 834 Data=64322
========================




Show all the node ==========================
key= 23   key= 32   key= 123   key= 223   key= 2239   key= 4332   key= 54455   key= 64322   key= 89777


zy__
关注
专栏目录
【数据结构与算法】五、哈希表和链表
lishili93的博客
07-05 1439
大家好，我是春风今天继续刷左神的算法视频，前面刷完了入门的查找和排序算法，也对排序算法做了一些总结。 现在开始刷结构部分，第一个结构是哈希表，然后是链表。哈希表的应用在Java中有现成的map结构，链表更多的是一些解法上的规律。如果哈希表内存储的是基本类型，比如：则内部是值传递，即存储的时候会拷贝当前的值，为一个新的string。如果是对象，则就是存储该对象的地址。链表分单向链表和双向链表，一般在Java中新建一个节点Node类，单向链表，类里包含： 双向链表多一个指向前一个的指针： 例题： 1.
链表实现哈希表以及哈希表的应用
weixin_45642150的博客
04-01 706
''' 哈希表 字典和集合 一个通过哈希函数来计算数据存储位置的数据结构，通常支持如下操作： insert:插入键值对 get ：如果存在键为key的键值对则返回其value，否则返回空值 delete:删除键为key的键值对 直接寻址表 关键字的全域U比较小时，一种简单而又有效的方法 缺点： 当域U很大，需要消耗大量内存 当域U很大，实际出现的key很少， 无法处理关键字不是数字的情况 直接寻址表：key为k的元素放在k位置上 哈希： 构建大小为m的寻址表T key为k的元
哈希表
wenxuegeng的专栏
07-27 356
哈希表定义哈希表就是将一堆杂乱的信息，根据他们关键词的特点，将其映射到一个连续的空间。
Hash Table哈希表和Hash List哈希链表的知识汇总
Aiphis的博客
10-10 1226
本文分为三个部分： 一 Hash Table概论 二 Linux源代码中的Hash List 三 Linux源代码中的Hash Table 一 Hash Table概论 字符串的算法一般大公司都会考到，我们首先要想到高效的hash。如百度查找一组字符串是否出现在某个文本中，这个不是考什么kmp，他们想听到的是hash。趋势科技考的是从某个文本中删除一组字符串，我想也是要hash吧。
哈希表、哈希冲突解决办法
baboon_chen
11-27 974
我们知道，普通数组能够直接寻址，在O(1)时间内能访问到数组中的任意位置。它需要足够大的空间，为每一个关键字保留一个位置。当关键字取值的范围很大，储存空间又有限时，能不能同样用数组的形式实现O(1)查找？哈希表(Hash Table)就是这样的数据结构，当实际储存的关键字集合，比所有可能的关键字的全集小许多时，使用一个长度有限的数组去储存这些关键字，从而节省大量的空闲空间。它也被称作为散列表，因为它的键是分散存储在数组中的。如图，黄色区域为键的全集，范围为0~99，绿色区域为实际存储的键。
Linux内核中的数据结构与算法（三）哈希链表
一个混迹在安全圈的宅女
03-11 555
四，哈希链表 谈到链表就不得不谈Linux内核中另外一个重要的结构，哈希链表。讨论这个结构前，你需要对哈希的最基本的概念要清楚哦，由于我们已经讲过Linux内核中的普通链表的结构，这里我们对比他们的区别来了解哈希链表会直观一些。 Linux链表认为双指针表头双循环链表对于HASH表来说过于浪费，因而设计了一套用于HASH表的hlist的数据结构，单指针表头双循环链表。hlish表头仅有一个指向首节点的指针，而没有指向尾节点的指针，这样在海量的HASH表中存储的表头就能减少一半的空间消耗。 定义和初始化
多核计算与程序设计（2009年3月1日出版）第一二三部分
12-19
第2部分介绍基础的数据结构与算法，包括数组、链表、哈希表、二叉树、AVL树、复合二叉树等基本数据结构，在链表那章中还讲解了多线程并行遍历的基本方法。 第3部分介绍多核并行计算方面的基础知识，并行编程包括常用...
链表的智能排序与索引算法.pptx
最新发布
05-28
### 链表的智能排序与索引算法 #### 一、链表智能排序算法的原理和优势 ...综上所述，链表智能排序与索引算法不仅提供了高效的排序和检索机制，还在不断进步和发展之中，为大数据处理带来了更多的可能性。
数据结构与算法-哈希查找算法原理和实际场景
数据结构和算法是计算机科学的基础知识，对于提高程序效率和解决复杂问题非常重要。 数据结构和算法的基本概念包括： - 线性表：一组具有线性关系的元素的集合，如数组、链表等。 - 树：由节点和边组成的一种层次...
并发数据结构与多核编程21-22秋季1
08-04
【并发数据结构与多核编程】是一门深入探讨面向多核系统的程序设计的课程，旨在让学生掌握并发编程的基础原理和实践经验。课程分为理论和实践两个部分，覆盖了从并发编程的基本概念到具体并发数据结构和算法的设计与...
哈希表的C语言实现
爱编程的小屁孩的博客
06-16 8459
一、学习要点： 1.哈希表是一个很神奇的东西，即解决了数组的增删的繁琐，也解决了链表的查找问题； 2.哈希表的哈希函数； 3.哈希表的冲突问题解决；什么叫做闭散列，什么叫做开散列；闭，严重遵守哈希内涵。开，有点开放的意味，解决冲突靠链表，有点变味的哈希； 二、相关数据结构解读： ...
哈希表数组链表表示法示例
martin_liang的专栏
01-06 2213
转自出处：http://www.cnblogs.com/molixiaoge/archive/2011/12/27/2303201.html #include using namespace std; #define MAXSIZE 10//哈希链表 数组个数 当然可以适当的增加或者减少 /* 注意点!!! 1.key值一定不能重复的 2.解决地址冲突法 本例用链表解决冲突即闭
哈希表（HashTable）
热门推荐
Cdreamfly的博客
07-13 5万+
哈希表：也叫做散列表。是根据关键字和值（Key-Value）直接进行访问的数据结构。也就是说，它通过关键字 key 和一个映射函数 Hash(key) 计算出对应的值 value，然后把键值对映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做哈希函数（散列函数），用于存放记录的数组叫做 哈希表（散列表）。 哈希表的关键思想是使用哈希函数，将键 key 和值 value 映射到对应表的某个区块中。可以将算法思想分为两个部分：哈希表的原理示例图如下所示： 哈希函数：将哈希表中元素的关键键值映射为元
数据结构---hash表
zion--6135的博客
08-13 947
/在hash表ht中，通过key得到value的指针。给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为。//创建一个hash表。
数组，链表和哈希表比较
u012864854的博客
03-31 5754
数组与链表的区别：（1）存储空间上：    链表存放的内存空间可以是连续的，也可以是不连续的，数组则是连续的一段内存空间。一般情况下存放相同多的数据时，数组占用较小的内存，而链表还需要存放其前驱和后继的空间。（2）长度的可变性：    链表的长度是按实际需要可以伸缩的，而数组的长度是在定义时要给定的，如果存放的数据个数超过了数组的初始大小，则会出现溢出现象。（3）查找效率：按序号查找时，数组可以随...
一个简单HashTable实现，哈希函数求模取余，链地址解决冲突
白话机器学习
04-25 1087
struct Node//定义节点结构 { Node* pNext; int val; Node(int n) { this->val=n; this->pNext=NULL; } }; //定义一个hashtable类 class HashTable { public: bool insert(int n);//插入一个数据 bool insert(int *pbegin
自己写的哈希表以及解决哈希冲突
编程的本质是数学问题
03-10 1195
哈希表就是键值key-value对，使用hash函数让key产生哈希值，当不同的key产生相同的哈希值时就是哈希冲突了，产生哈希冲突可以使用拉链法。 hash.c #include #include #include #include "hash.h" static unsigned int table_size[] = { 7, 13, 31, 61, 127, 251, 509
多任务环境下高效数据结构与算法详解
作者深入讲解了如何将这些数据结构转化为支持并发操作的设计，这在复合数据结构（如哈希链表、哈希红黑树和哈希AVL树）和动态数据结构（如动态环形队列和动态内存管理算法）中得到了体现。 复合数据结构部分介绍了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值