精华内容
下载资源
问答
  • /为班级30个人的姓名设计一个哈希表,假设姓名用汉语拼音表示。要求用除留余数法 ...2、创建哈希表,将ASCII码取余得KEY值,若未发生冲突存入哈希表 3、发生冲突调用冲突函数。进行线性探测。最后存入哈希表。
  • 哈希表 用链地址法解决冲突:(哈希函数是按名字第一个大写字母分的) 输入内容:学生的姓名跟成绩 操作:插入、修改、查找、删除学生;以及输出哈希表
  • 哈希表和哈希算法是什么关系A hash table, also known as a hash map, is a data structure that maps keys to values. It is one part of a technique called hashing, the other of which is a hash function. A ...

    哈希表和哈希算法是什么关系

    A hash table, also known as a hash map, is a data structure that maps keys to values. It is one part of a technique called hashing, the other of which is a hash function. A hash function is an algorithm that produces an index of where a value can be found or stored in the hash table.

    哈希表(也称为哈希图)是一种将键映射到值的数据结构。 它是一种称为散列的技术,另一部分是散列函数。 哈希函数是一种算法,它生成一个索引,该索引可在哈希表中找到或存储值。

    Some important notes about hash tables:

    有关哈希表的一些重要说明:

    1. Values are not stored in a sorted order.

      值未按排序顺序存储。
    2. You mush account for potential collisions. This is usually done with a technique called chaining. Chaining means to create a linked list of values, the keys of which map to a certain index.

      您必须考虑潜在的碰撞。 通常使用称为链接的技术来完成此操作。 链接意味着创建值的链接列表,其键映射到某个索引。

    哈希表的实现 (Implementation of a hash table)

    The basic idea behind hashing is to distribute key/value pairs across an array of placeholders or "buckets" in the hash table.

    散列背后的基本思想是在散列表中的一组占位符或“存储桶”之间分布键/值对。

    A hash table is typically an array of linked lists. When you want to insert a key/value pair, you first need to use the hash function to map the key to an index in the hash table. Given a key, the hash function can suggest an index where the value can be found or stored:

    哈希表通常是链接列表的数组。 当您要插入键/值对时,首先需要使用哈希函数将键映射到哈希表中的索引。 给定一个键,哈希函数可以建议一个索引,可以在其中找到或存储该值:

    index = f(key, array_size)

    This is often done in two steps:

    这通常分两个步骤完成:

    hash = hashfunc(key)
    index = hash % array_size

    Using this method, hash is independent of the size of the hash table. hash is reduced to an index – a number between 0, the start of the array, and array_size - 1, the end of the array – using the modulo (%) operator.

    使用此方法, hash与哈希表的大小无关。 使用模(%)运算符将hash减少为一个索引-一个介于0(在数组的开头)和array_size - 1 (在数组的结尾)之间的数字。

    Consider the following string, S:

    考虑以下字符串S

    string S = “ababcd”

    You need to count the frequency of all the characters in S. The easiest way to do this is to iterate through all the possible characters and count the frequency of each, one by one.

    您需要计算S中所有字符的频率。 最简单的方法是遍历所有可能的字符并逐个计数每个字符的频率。

    This works, but it's slow – the time complexity of such an approach is O(26*N), with N being the size of the string S multiplied by 26 possible characters from A-Z.

    这可行,但是很慢–这种方法的时间复杂度为O(26 * N),其中N是字符串S大小乘以AZ中的26个可能的字符。

    void countFre(string S)
        {
            for(char c = ‘a’;c <= ‘z’;++c)
            {
                int frequency = 0;
                for(int i = 0;i < S.length();++i)
                    if(S[i] == c)
                        frequency++;
                cout << c << ‘ ‘ << frequency << endl;
            }
        }

    Output:

    输出:

    a 2
    b 2
    c 1
    d 1
    e 0
    f 0
    …
    z 0

    Let's take a look at a solution that uses hashing.

    让我们看一下使用哈希的解决方案。

    Take an array and use the hash function to hash the 26 possible characters with indices of the array. Then iterate over S and increase the value of the current character of the string with the corresponding index for each character.

    取得一个数组,并使用哈希函数对带有数组索引的26个可能的字符进行哈希处理。 然后遍历S并使用每个字符的相应索引增加字符串的当前字符的值。

    The complexity of this hashing approach is O(N), where N is the size of the string.

    这种哈希方法的复杂度为O(N),其中N是字符串的大小。

    int Frequency[26];
    
        int hashFunc(char c)
        {
            return (c - ‘a’);
        }
    
        void countFre(string S)
        {
            for(int i = 0;i < S.length();++i)
            {
                int index = hashFunc(S[i]);
                Frequency[index]++;
            }
            for(int i = 0;i < 26;++i)
                cout << (char)(i+’a’) << ‘ ‘ << Frequency[i] << endl;
        }

    Output

    输出量

    a 2
    b 2
    c 1
    d 1
    e 0
    f 0
    …
    z 0

    哈希冲突 (Hash Collisions)

    Since your hash map will probably be significantly smaller than the amount of data you're processing, hash collisions are unavoidable. There are two main approaches to handling collisions: chaining and open addressing.

    由于您的哈希映射可能会大大小于您正在处理的数据量,因此哈希冲突不可避免。 处理冲突有两种主要方法: 链接开放式寻址

    链式 (Chaining)

    As mentioned earlier, chaining means that each key/value pair in the hash table, the value is a linked list of data rather than a single cell.

    如前所述,链接意味着哈希表中的每个键/值对,值都是数据的链表,而不是单个单元格。

    For example, imagine that the key 152 holds the value "John Smith". If the value "Sandra Dee" is added to the same key, "Sandra Dee" is added as another element to key 152, just after "John Smith".

    例如,假设键152的值是“ John Smith”。 如果将值“ Sandra Dee”添加到同一键,则在“ John Smith”之后,将“ Sandra Dee”作为另一个元素添加到键152。

    152: [["John Smith", "p01"]]
    
    ...
    
    152: [["John Smith", "p01"] ["Sandra Dee", "p02"]]

    The main drawback of chaining is the increase in time complexity. Instead of 0(1) as with a regular hash table, each lookup will take more time since we need to traverse each linked list to find the correct value.

    链接的主要缺点是时间复杂度的增加。 代替常规哈希表的0(1),每次查找将花费更多时间,因为我们需要遍历每个链表以找到正确的值。

    开放式寻址 (Open addressing)

    Open addressing means that, once a value is mapped to a key that's already occupied, you move along the keys of the hash table until you find one that's empty. For example, if "John Smith" was mapped to 152, "Sandra Dee" will be mapped to the next open index:

    开放式寻址意味着,将值映射到已被占用的键之后,您将沿着哈希表的键移动,直到找到一个空的键。 例如,如果“ John Smith”映射到152,则“ Sandra Dee”将映射到下一个打开的索引:

    152: ["John Smith", "p01"] 
    
    ...
    
    152: ["John Smith", "p01"],
    153: ["Sandra Dee", "p02"]

    The main drawback to open addressing is that, when you look up values, they might not be at the key map you expect them at. Instead, you have to traverse different parts of the hash table to find the value you're looking for.

    开放式寻址的主要缺点是,当您查找值时,它们可能不在您期望的键映射中。 相反,您必须遍历哈希表的不同部分以查找所需的值。

    翻译自: https://www.freecodecamp.org/news/hash-tables/

    哈希表和哈希算法是什么关系

    展开全文
  • 散列查找算法_哈希表

    2019-12-08 11:11:01
    程序先调用自己写的Create函数创建一个长度为13的哈希表,原始数据是:{10,9,8,7,5,4,6,3,2,1,95},长度为11,这个程序使用的是除留余数法,构建的哈希表为:{0,1,2,3,4,5,6,7,8,9,10,95,0}. 然后再调用Haxi_Sou...
  • 哈希表创建

    千次阅读 2018-09-06 15:30:09
    哈希表的拉链法实现: 定义哈希表的定义链结点 #define HASHSIZE 10 typedef unsigned int uint; typedef struct Node{ const char* key; const char* value; Node *next; }Node; class HashTable{ p...

    2018.09.06

    代码块

    哈希表的拉链法实现:

    定义哈希表的定义链结点

    #define HASHSIZE 15
    typedef unsigned int uint;
    typedef struct Node{
        const char* key;
        const char* value;
        Node *next;
    }Node;
    
    class HashTable{
    private:
        Node* node[HASHSIZE];
    public:
        HashTable();
        uint hash(const char* key);
        Node* lookup(const char* key);
        bool install(const char* key,const char* value);
        const char* get(const char* key);
        void display();
    };
    
    HashTable::HashTable(){
        for (int i = 0; i < HASHSIZE; ++i)
        {
            node[i] = NULL;
        }
    }

    定义哈希表的Hash算法:time33算法(没找到什么理论可以说明这种算法的合理性,据说只是通过测试和实践发现这个算法是比较好的)

    uint HashTable::hash(const char* key){
        uint hash=0;
        for (; *key; ++key)
        {
            hash=hash*33+*key;
        }
        return hash%HASHSIZE;
    }

    哈希表的查找

    Node* HashTable::lookup(const char* key){
        Node *np;
        uint index;
        index = hash(key);
        for(np=node[index];np;np=np->next){
            if(!strcmp(key,np->key))
                return np;
        }
        return NULL;
    }

    插入一个新的结点,首先是查看该key值的结点是否存在,如果存在则更改value值就好,如果不存在,则插入新结点。

    bool HashTable::install(const char* key,const char* value){
        uint index;
        Node *np;
        if(!(np=lookup(key))){
            index = hash(key);
            np = (Node*)malloc(sizeof(Node));
            if(!np) return false;
            np->key=key;
            np->next = node[index];
            node[index] = np;
        }
        np->value=value;
        return true;
    }

    链地址法可以解决哈希冲突


    展开全文
  • 6-4 创建哈希表及查找(拉链法) (10分) 实现哈希表创建及查找算法,哈希函数使用除余法,用拉链法处理冲突。 函数接口定义: void CreateHash(HashTable HT[],int n); //输入不大于m的n个不为0(0表示空值)的数,用...

    6-4 创建哈希表及查找(拉链法) (10分)

    实现哈希表创建及查找算法,哈希函数使用除余法,用拉链法处理冲突。

    函数接口定义:

    void CreateHash(HashTable HT[],int n); //输入不大于m的n个不为0(0表示空值)的数,用拉链法解决冲突构造散列表
    float ASL(HashTable HT[]); //计算平均查找长度
    

    其中 HT 表示哈希表, n表示记录数。

    裁判测试程序样例:

    #include<iostream>
    using namespace std;
    
    #define P 13
    
    typedef struct HashNode{
       int  key;
       struct HashNode *next; 
    }HashNode,* HashTable;
    
    void CreateHash(HashTable HT[],int n);
    float ASL(HashTable HT[]);
    
    int main()
    {
        int i,n;
        HashTable HT[P];
        for(i=0;i<P;i++)
         HT[i]=NULL;
        cin >> n;
        CreateHash(HT,n);
        cout << ASL(HT);
        return 0;
    }
    /* 请在这里填写答案 */
    

    输入样例:

    12
    19 14 23 1 68 20 84 27 55 11 10 79
    

    输出样例:

    输出拓扑序列。

    1.75 
    

    答案样例:

    void CreateHash(HashTable HT[], int n) {//创作不易,点个赞吧,新春快乐~
    	int hash_table[P];//创建一个辅助数组
    	int temp;//存放余数
    	for(int i=0; i<n; i++)
    		cin >> hash_table[i];
    	for(int i=0; i<n; i++) {
    		temp = hash_table[i] % P;//求余数
    		if(HT[temp]==NULL) {//头为空插头后面 
    			HT[temp] = (HashTable)malloc(sizeof(HashNode));
    			HashTable p = (HashTable)malloc(sizeof(HashNode));
    			p->key = hash_table[i];
    			HT[temp]->next = p;
    			p->next = NULL;
    		} else {//头不为空找到尾,查到尾后面 
    			HashTable p = (HashTable)malloc(sizeof(HashNode));
    			p = HT[temp];
    			while(p->next!=NULL) {
    				p = p->next;
    			}
    			HashTable q = (HashTable)malloc(sizeof(HashNode));
    			q->key = hash_table[i];
    			p->next = q;
    			q->next = NULL;
    		}
    	}
    }
    //计算平均查找长度
    float ASL(HashTable HT[]) {
    	double sum=0, len=0;//sum记录总步数,len记录有几个元素 
    	for(int i=0; i<P; i++) {
    		if(HT[i] == NULL)
    			continue;
    		int cnt=1;
    		HashTable p = (HashTable)malloc(sizeof(HashNode));
    		p = HT[i];
    		while(p->next!=NULL) {
    			p = p->next;
    			sum+=cnt;
    			cnt++;
    			len++;
    		}
    	}
    	return sum/len;//总步数除以元素个数也就是平均查找长度 
    }
    

    感谢您的阅读,点个赞吧❤⭐
    哔哩哔哩/bilibili:羊卓的杨
    公众号:羊卓的杨

    展开全文
  • 数据结构与算法分析:哈希表

    千次阅读 2015-09-25 07:41:12
    哈希表又叫散列表,是实现字典操作的一种有效数据结构。哈希表的查询效率极高,在没有冲突(后面会介绍)的情况下可做到一次存取便能得到所查记录,在理想情况下,查找一个元素的平均时间为O(1)(最差情况下散列表中...

    以下是阅读了《算法导论》后,对哈希表的一些总结:

    哈希表又叫散列表,是实现字典操作的一种有效数据结构。哈希表的查询效率极高,在没有冲突(后面会介绍)的情况下可做到一次存取便能得到所查记录,在理想情况下,查找一个元素的平均时间为O(1)(最差情况下散列表中查找一个元素的时间与链表中查找的时间相同:O(n),但实际情况中一般散列表的性能是比较好的)。

    哈希表就是描述key—value对的映射问题的数据结构,更详细的描述是:在记录的存储位置和它的关键字之间建立一个确定的对应关系h,使每个关键字与哈希表中唯一一个存储位置相对应。我们称这个对应关系f为哈希/散列函数,这个存储结构即为哈希/散列表。

    一、直接寻址表

    当关键字的全域U比较小时,直接寻址是一种简单而有效的技术,它的哈希函数很简单:f(key) = key,即关键字大小直接与元素所在的表位置序号相等。如果关键字不是整数,我们需要通过某种手段将其转换为整数,比如可以将字符关键字转化为其在字母表中的序号作为关键字。直接寻址法的优点是不会出现两个关键字对应到同一个地址的情况(即不会出现f(key1) = f(key2)的情况),因此不用处理冲突。但是,直接寻址表也有着天然的局限性,即如果全域U很大,则在一台标准的计算机可用内存容量中,要存储大小为U的一张表并不实际。

    二、散列表

    上面说到,在处理实际数据的时候,全域U往往会很大,则在一台标准的计算机可用内存容量中,要存储大小为U的一张表也许不太实际,此时实际需要存储的关键字集合K可能相对U来说很小,这时散列表需要的存储空间要比直接表少很多。

    散列表T通过散列函数f计算出关键字key在表中的位置,这些位置被称为“槽”。散列函数f将关键字域U映射到散列表T[0...m-1]的槽位上。由于关键字的个数要大于槽的个数,这里会出现一个问题:若干个关键字可能映射到了表的同一个位置处,我们称这种情形为冲突。我们希望散列表在节省空间的同时,其性能要接近于O(1),因此需要尽量避免冲突,通常的策略是尽可能地设计更好的哈希函数f,将关键字尽可能随机地映射到散列表的每个位置上(为什么说尽可能?因为这里关键字的个数|U|肯定大于散列表的槽个数m,因此至少有两个关键字被映射到同一个槽中,只依靠哈希函数f是无法完全避免冲突的)。

    三、哈希函数

    哈希函数的构造方法很多,最好的情况是:对于关键字结合中的任一个关键字,经哈希函数映射到地址集合中任何一个地址的概率相等,也就是说,关键字经过哈希函数得到一个随机的地址,以便使一组关键字的哈希地址均匀分布在整个地址空间中,从而减少冲突。同样,由于多数哈希函数都是假定关键字的全域为自然数集N={0、1、2….},因此所给关键字如果不是自然数,就要先想办法将其转换为自然数。下面我们就来看常用的哈希函数。

    1.直接定址法

    对应前面的直接寻址表,关键字与哈希表中的地址有着一一对应关系,因此不需要处理冲突。

    2.除法散列法

    哈希函数:f(key) = key % m

    函数对所给关键字key取余,这里 m 必须不能大于哈希表的长度len通常 m 可取一个不太接近2的整数次幂的素数

    3.乘法散列法

    用关键字key乘上A(0 < A < 1),取出其小数部分,然后用 m 乘以小数的值,再向下取整,该函数写为:f(key) = floor(m * (key * A % 1))

    其中,(key * A % 1)是取(key * A)的小数部分,该函数涉及到参数A的取值问题。Knuth认为,A = (sqrt(5)-1)/2 = 0.6180339877...是个比较理想的值,事实上,该点就是黄金分割点。

    除法散列法乘法散列法是较为常用的哈希函数设计方法,事实上方法还有很多种,如全域散列法折叠法数字分析法等,更多的介绍请参考相关书籍。

    四、冲突处理

    前面提到,为了节省空间,表中槽的数目小于关键字的数目,只是通过设计好的哈希函数不可能完全避免冲突。下面介绍两种解决冲突的方法:链接法开放定址法

    1.链接法(chaining)

    链接法的思路很简单:如果多个关键字映射到了哈希表的同一个位置处(将这些关键字称为同义词),则将这些同义词记录在同一个线性链表中,该槽有一个指针,它指向存储所有散列到该槽的元素的链表表头,如下图所示:

    这里写图片描述

    图中,关键字k1k4映射到了哈希表的同一个位置处,k5、k2、k7映射到了哈希表的同一个位置处。《算法导论》提到,为了更快地删除某个元素,可以将链表设计为双向链表。如果表是单链接的,则为了删除元素x,首先必须在表T[h(x,key)]中找到元素x,然后通过更改x的前去元素的next属性,把x从链表中删除。在单链表的情况下,删除和查找操作的渐近运行时间相同。另一个例子如下:

    这里写图片描述

    2.开放定址法(open addressing)

    在开放定址法中,所有的元素都存放在散列表中,也即是说,每个表项或包含动态集合的一个元素,或为空,不再使用链表。哈希表中的槽t不仅向哈希函数值等于t的同义词开放,而且向哈希函数值不等于t的记录开放,允许以“抢占”的方式争取哈希地址。

    该方法采用如下公式记性再散列:

    F(key,i) = (f(key) + di) % len

    其中,f(key)为哈希函数,len为哈希表长,di为增量序列,它可能有如下三种情况:

    • di = 1,2,3...m-1

    • di = 1,-1,4,-4,9,-9...k^2,-k^2

    • di为伪随机序列

    采用第一种序列的叫做线性探测再散列,采用第二种序列的叫做二次探测再散列,采用第三种序列的叫做随机探测再散列。说白了,就是在发生冲突时,将关键字应该放入的位置向前或向后移动若干位置,比如采取第一种序列时,如果遇到冲突,就向后移动一个位置来检测,如果还发生冲突,继续向后移动,直到遇到一个空槽,则将该关键字插入到该位置处。

    线性探测比较容易实现,但是它存在一个问题,称为一次群集。随着连续被占用的槽不断增加,平均查找时间也随之不断增加,群集现象很容易出现,这是因为当一个空槽前有i个满槽时,该空槽为下一个将被占用的概率为(di+1)len。

    同样采用二次探测的方法,会产生二次群集,因为每次遇到冲突时,寻找插入位置时都是在跳跃性前进或后退,因此这个相对于一次群集来说,比较轻度。

    五、一些例子

    已知关键字序列:26,36,41,38,44,15,68,12,06,51,25

    用除法散列法构造哈希函数,线性探测再散列法解决冲突。现在需要:①建哈希表;②求查找成功和失败的平均搜索长度(ASL)。

    解法:题中关键字个数n = 11,设装载因子α = 0.75m = n / α,取m为素数13。哈希函数:f(key) = key % 13,以下图片给出了建哈希表的步骤:

    这里写图片描述

    哈希表的查找性能分析:

    这里写图片描述

    这里写图片描述

    六、代码实现

    下面用代码实现一个哈希表,这里采用链接法来处理冲突,描述数据结构的头文件的代码如下:

    #define M 7     //哈希函数中的除数,必须小于等于表长
    typedef int ElemType;
    
    // 该哈希表采用链接法解决冲突问题
    
    typedef struct Node 
    {   //Node为链表节点的数据结构
        ElemType data;
        struct Node *next;
    }Node,*pNode;
    
    // 哈希表每个槽的数据结构
    typedef struct HashNode
    {   
        pNode first;    // first指向链表的第一个节点
    }HashNode,*HashTable;
    
    // 创建哈希表
    HashTable create_HashTable(int);
    
    // 在哈希表中查找数据
    pNode search_HashTable(HashTable, ElemType);
    
    // 插入数据到哈希表
    bool insert_HashTable(HashTable,ElemType);
    
    // 从哈希表中删除数据
    bool delete_HashTable(HashTable,ElemType);
    
    // 销毁哈希表
    void destroy_HashTable(HashTable,int);

    首先建立一个空哈希表,而然后执行插入、删除、查询等操作,最后销毁哈希表,哈希表的实现代码如下:

    #include<stdio.h>
    #include<stdlib.h>
    #include "data_structure.h"
    
    // 创建n个槽的哈希表
    HashTable create_HashTable(int n)
    {
        int i;
        HashTable hashtable = (HashTable)malloc(n*sizeof(HashNode));
        if(!hashtable)
        {
            printf("hashtable malloc faild,program exit...");
            exit(-1);
        }
    
        // 将哈希表置空
        for(i=0;i<n;i++)
            hashtable[i].first = NULL;
    
        return hashtable;
    }
    
    // 在哈希表中查找数据,哈希函数为H(key)=key % M
    // 查找成功则返回在链表中的位置
    // 查找不成功则返回NULL
    pNode search_HashTable(HashTable hashtable, ElemType data)
    {
        if(!hashtable)
            return NULL;
    
        pNode pCur = hashtable[data%M].first;
        while(pCur && pCur->data != data)
            pCur = pCur->next;
    
        return pCur;
    }
    
    // 向哈希表中插入数据,哈希函数为H(key)=key%M
    // 如果data已存在,则返回fasle
    // 否则,插入对应链表的最后并返回true
    bool insert_HashTable(HashTable hashtable,ElemType data)
    {
        // 如果已经存在,返回false
        if(search_HashTable(hashtable,data))
            return false;
    
        // 否则为插入数据分配空间
        pNode pNew = (pNode)malloc(sizeof(Node));
        if(!pNew)
        {
            printf("pNew malloc faild,program exit...");
            exit(-1);
        }
        pNew->data = data;
        pNew->next = NULL;
    
        // 将节点插入到对应链表的最后
        pNode pCur = hashtable[data%M].first;
        if(!pCur)   // 插入位置为链表第一个节点的情况
            hashtable[data%M].first = pNew;
        else    // 插入位置不是链表第一个节点的情况
        {   // 只有用pCur->next才可以将pNew节点连到链表上,
            // 用pCur连不到链表上,而是连到了pCur上
            // pCur虽然最终指向链表中的某个节点,但是它并不在链表中
            while(pCur->next)
                pCur = pCur->next;
            pCur->next = pNew;
        }
    
        return true;
    }
    
    // 从哈希表中删除数据,哈希函数为H(key)=key % M
    // 如果data不存在,则返回fasle,
    // 否则,删除并返回true
    bool delete_HashTable(HashTable hashtable,ElemType data)
    {
        // 如果没查找到,返回false
        if(!search_HashTable(hashtable,data))
            return false;
        // 否则,删除数据
        pNode pCur = hashtable[data%M].first;
        pNode pPre = pCur;  // 被删节点的前一个节点,初始值与pCur相同
        if(pCur->data == data)  // 被删节点是链表的第一个节点的情况
            hashtable[data%M].first = pCur->next;
        else
        {   // 被删节点不是第一个节点的情况
            while(pCur && pCur->data != data)
            {
                pPre = pCur;
                pCur = pCur->next;
            }
            pPre->next = pCur->next;
        }
        free(pCur);
        pCur = 0;
        return true;
    }
    
    // 销毁槽数为n的哈希表
    void destroy_HashTable(HashTable hashtable,int n)
    {
        int i;
        // 先逐个链表释放
        for(i=0;i<n;i++)
        {
            pNode pCur = hashtable[i].first;
            pNode pDel = NULL;
            while(pCur)
            {
                pDel = pCur;
                pCur = pCur->next;
                free(pDel);
                pDel = 0;
            }
        }
        // 最后释放哈希表
        free(hashtable);
        hashtable = 0;
    }

    最后测试代码:

    #include<stdio.h>
    #include "data_structure.h"
    
    int main()
    {
        int len = 15;   // 哈希表长,亦即表中槽的数目
        printf("We set the length of hashtable %d\n",len);
    
        //创建哈希表并插入数据
        HashTable hashtable = create_HashTable(len);
        if(insert_HashTable(hashtable,1))
            printf("insert 1 success\n");
        else 
            printf("insert 1 fail,it is already existed in the hashtable\n");
        if(insert_HashTable(hashtable,8))
            printf("insert 8 success\n");
        else 
            printf("insert 8 fail,it is already existed in the hashtable\n");
        if(insert_HashTable(hashtable,3))
            printf("insert 3 success\n");
        else 
            printf("insert 3 fail,it is already existed in the hashtable\n");
        if(insert_HashTable(hashtable,10))
            printf("insert 10 success\n");
        else 
            printf("insert 10 fail,it is already existed in the hashtable\n");
        if(insert_HashTable(hashtable,8))
            printf("insert 8 success\n");
        else 
            printf("insert 8 fail,it is already existed in the hashtable\n");
    
        //查找数据
        pNode pFind1 = search_HashTable(hashtable,10);
        if(pFind1)
            printf("find %d in the hashtable\n",pFind1->data);      
        else 
            printf("not find 10 in the hashtable\n");
        pNode pFind2 = search_HashTable(hashtable,4);
        if(pFind2)
            printf("find %d in the hashtable\n",pFind2->data);      
        else 
            printf("not find 4 in the hashtable\n");
    
        //删除数据
        if(delete_HashTable(hashtable,1))
            printf("delete 1 success\n");
        else 
            printf("delete 1 fail");
        pNode pFind3 = search_HashTable(hashtable,1);
        if(pFind3)
            printf("find %d in the hashtable\n",pFind3->data);      
        else 
            printf("not find 1 in the hashtable,it has been deleted\n");
    
        // 销毁哈希表
        destroy_HashTable(hashtable,len);
        return 0;
    }
    

    七、参考资料

    《算法导论》 第三版 (美)科曼(Cormen,T.H.) 等著,殷建平 等译
    http://blog.csdn.net/ns_code

    展开全文
  • 例如:有一个从1到100岁的人口数字统计,其中,年龄作为关键字,哈希函数取关键字自身。 但这种方法效率不高,时间复杂度是O(1),空间复杂度是O(n),n是关键字的个数 2、数字分析法 有学生的生日数据如下: 年.月...
  • 哈希表 算法

    2013-06-01 08:50:24
    哈希表也有一些缺点它是基于数组的,数组创建后难于扩展某些哈希表被基本填满时,性能下降得非常严重。这个问题是哈希表不可避免的,即冲突现象:对不同的关键字可能得到同一哈希地址。 编辑摘要 目录 ...
  • 哈希算法简介与常见的哈希生成算法什么是哈希算法哈希哈希表key值与位置的映射关系常见的哈希生成算法折叠法移位叠加边界叠加平方取中法进制转换法取模法伪随机数法哈希算法的特点哈希算法的应用 什么是哈希算法 ...
  • 实现哈希表创建及查找算法,哈希函数使用除余法,用拉链法处理冲突。 函数接口定义: void CreateHash(HashTable HT[],int n); //输入不大于m的n个不为0(0表示空值)的数,用拉链法解决冲突构造散列表 float ASL...
  • 哈希表 哈希表定义 哈希表(Hash Table)又称散列表,是除顺序表存储结构、链接表存储结构和索引表存储结构之外的又一种存储线性表的存储结构。 哈希表(散列表)的基本概念 基本思想: 记录的...
  • JavaScript实现数据结构与算法(二)哈希表2. 集合2.1 集合的特点 (二)哈希表 学习笔记:coderwhy的JavaScript实现数据结构与算法的课程 2. 集合 2.1 集合的特点 ...
  • 哈希表算法

    2015-07-25 14:00:58
    哈希表是种数据结构,它可以提供快速的插入操作和查找操作。第一次接触哈希表时,它的优点多得让人难以置信。不论哈希表中有多少数据,插入和删除(有时包括侧除)只需要接近常量的时间即0(1)的时间级。实际上,这...
  • 哈希表之二----链地址法创建哈希表

    千次阅读 2014-05-10 15:04:32
    解决哈希表地址冲突的一个
  • 哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现哈希表的建立与运用C语言实现
  • 实现哈希表的相关运算算法

    千次阅读 2019-02-13 09:49:56
    * 实现哈希表的相关运算算法 * 实验目的: * 领会哈希表的构造和查找过程及其相关算法设计 * 实验内容: * 设计程序,实现哈希表的相关运算,并完成如下功能: * 1、建立关键字序列(16, 74, 60, 43, 54, 90, 46, 31, 29...
  • 散列技术是在记录的存储位置和它的...采用散列技术将记录存储在一块连续的存储空间中,这块连续的存储空间成为散列表或者哈希表。 //哈希散列表 #include&lt;iostream&gt; using namespace std; type...
  • Python实现哈希表,Python完成哈希表数据结构
  • C++STL之哈希表

    千次阅读 2021-01-01 22:17:16
    C++ STL中,哈希表对应的容器是unordered_map(since C++ 11)。根据 C++ 11 标准的推荐,用unordered_map代替hash_map。 哈希表 先来回顾一下数据结构中哈希表相关的知识。 哈希表是根据关键码值(key value)而...
  • 数据结构与算法(一)哈希表(Hash Table)简单实现哈希表标准实现LeetCode思想实践: 哈希表是一种数据结构,其中数据以关联方式存储(以key, value格式)。Key或index是唯一的。这种存储方式使得过后更容易找到...
  • 第1关:哈希表初始化 本关任务:初始化哈希表满足下面要求。 将关键字序列(7、8、30、11、18、9、14)散列存储到散列表中, 散列函数为: H(key) = (key*3) MOD 7,处理冲突采用线性探测再散列法,要求装填(载)...
  • 查找--理解哈希算法并实现哈希表

    千次阅读 2017-06-01 22:12:17
    哈希表创建 1.首先将表中各节点的关键字置空; 2.使用插入算法将给定的关键字序列一次插入哈希表中。 哈希表的插入 1.通过查找算法找到待插记录在表中的位置; 2.若在表中找到待插记录,则不必...
  • C语言实现哈希表

    千次阅读 2020-03-14 21:07:06
    C语言实现哈希表 在某种情况下我们可能要从一个非常大的数据结构中去查询某些数据是否存在,不用考虑内存占用,只要求查找起来非常快,要怎么做?遍历肯定能实现,但是查找速度感人,用数组,链表去存储都不太合适。...
  • 摘要算法(哈希算法)

    2021-09-19 23:57:51
    通过哈希函数,可以为数据创建"数组指纹"(散列值/哈希值),哈希值通常是一个短的随机字母和数字组成的字符串。消息认证流程如下: 在上述认证流程中,信息收发双方在通信前已经商定好了具体的哈希算法,并且该...
  • 数据结构与算法哈希表

    千次阅读 多人点赞 2020-05-22 19:24:29
    数据结构与算法哈希表 该系列为博主自己学习记录数据结构与算法的实现。 本篇文章主要介绍哈希表(Hash Table,又称散列表)的原理、部分源码、以及练习实现。 目录数据结构与算法哈希表一、哈希表原理(一)、...
  • 运用数据结构和算法中的哈希算法,用MFC来实现该算法 运用数据结构和算法中的哈希算法,用MFC来实现该算法
  • 输入一组关键字,并建立哈希表算法(用链地址法来处理冲突)
  • python 算法——哈希表

    2019-06-11 09:47:22
    散列表(Hash table,也叫哈希表),是根据关键码值(Key和value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 91,825
精华内容 36,730
关键字:

创建哈希表的算法