精华内容
下载资源
问答
  • 哈希表实现的统计关键字频度

    千次阅读 2011-10-04 21:31:41
    #include #include #include //参数化输入\输出 #include #include //using namespace //名称空间 #define TOTAL 40 //39个关键字 #define
    #include <stdio.h>
    #include <string.h>
    #include <iomanip.h> //参数化输入\输出
    #include <stdlib.h>
    #include <conio.h>
    //using namespace //名称空间
    #define TOTAL 40               //39个关键字
    #define MAXLEN 10              //关键字长度
    #define HASHLEN 41             //哈希表长度41
    #define M 40
    
    typedef struct             //哈希表 结构体   
    {
    	char keyword[MAXLEN];     //关键字
    	int count;             //记录频度
    	int con;               //记录冲突次数
    }HASH;
    
    //全局变量
    int cont=0;               //统计关键词个数
    char KeyWords[TOTAL][MAXLEN]={ "asm","auto","break","case","cdecl","char",
                                   "const","continue","default","do","double",
    							   "else","enum","extern","far","float","for",
    							   "goto","huge","if","int","interrupt","long",
    							   "near","pascal","register","return","short",
    							   "signed","sizeof","static","struct","switch",
    							   "typedef","union","unsigned","void","volatile",
                                   "while"};                //C语言中的39个关键字存入二维数组中,排好序的数组
    HASH HS[HASHLEN];      //建立结构体HS
    //函数声明
    void Show(int key);
    int Read(char *filename);   
    int isLetter(char ch);
    int isKeyWords(char *word);
    int FindHX(char *keyword);
    int CreatHX(char *keyword);
    int GetFreePos(int key);
    int GetKey(char *keyword);
    void main()
    {
    	char orz; 
        int flag=1,i,count,key,has;
    	char filename[128],word[MAXLEN];
        while(flag)
    	{
    		printf("\t\tA.读取一个文件\n");
    	    printf("\t\tB.输出Hash表(关键字总数,冲突次数)\n");
    	    printf("\t\tC.查询某关键字在Hash表中的情况\n");
    	    printf("\t\tD.显示Hash表中的冲突关键字\n");
    	    printf("\t\tE.显示C语言关键字的Hash函数值(作为对照)\n");
    	    printf("\t\tF.退出\n\n");
    		printf("\t\t请输入序号(A--F):");
            scanf("%c",&orz);
    		switch(orz) //选择  
    		{
    		    case 'a':
    			case 'A':
    				system("cls");                         //清屏函数
                    printf("请输入要读取的文件名(文件必须与程序在同一目录下):");    //比如输入:a.cpp
    				scanf("%s",&filename);
    				Read(filename);
    			    printf("\n按任意键返回...");
    			    getch();
    			    system("cls");
    				break;
    		    case 'b':
    			case 'B':
    				getchar();
    				system("cls");
    				printf("每次显示5行,请按回车键继续!\n");
    				for(i=0;i<HASHLEN;i++)
    				{
    			  	    Show(i); 
    				    if((i+1)%5==0)
    						getchar();  //为了清晰,每次显示5行
    				}
    			    printf("关键字总数为: %d\n",cont);
    			    printf("\n按任意键返回...");
    			    getch();
    			    system("cls");
    			    break;
    		    case 'c':
    			case 'C':
    				system("cls");
    				printf("请输入你想要查找的关键字: ");
    			    scanf("%s",&word);
    			    printf("\n");
    			    Show(FindHX(word));
    				printf("\n按任意键返回...");
    			    getch();
    			    system("cls");
    			    break;
    		    case 'd':
    			case 'D':
    				system("cls");
    			    printf("\t冲突关键字列表\n\n");
    			    count=0;
    			    for(i=0;i<HASHLEN;i++)
    				{
    				    if(strlen(HS[i].keyword)>0)
    					{
    					    key=GetKey(HS[i].keyword);
    					    if(key!=i)
    						{
    						    count++;
    						    printf("\t关键字:%s",HS[i].keyword);
    						    printf("\t哈希表当前位置:%d",i);
    						    printf("\t冲突次数:%d\n",HS[i].con);
    						}
    					}
    				}
    			    if(count==0) 
    				    printf("没有冲突\n");
    			    else
    		 	        printf("\n\t\t\t冲突关键字共:%d个\n",count);
    				printf("\n按任意键返回...");
    			    getch();
    			    system("cls");
    			    break;
    		    case 'e':
    			case 'E':
    				getchar();
    				system("cls");
    				printf(" C语言中的关键字和其在哈希表的位置:\n");
    			    for(i=0;i<TOTAL;i++)
    				{
    					has=GetKey(KeyWords[i]);
    					printf("[%-2d]%-11s",has,KeyWords[i]);
    					if((i+1)%5==0)
    					    printf("\n");
    				}
    			    printf("\n");
    				printf("\n按任意键返回...");
    			    getch();
    			    system("cls");
    				break;
    		    case 'f':
    			case 'F':
    				flag=0;
    				break;
    			default:
    			    system("cls");
    		}
    	}
    }
    
    int Read(char *filename)
    {
    	char word[MAXLEN],ch,ch1;
    	int i;
    	FILE *read;                            //建立一个指像FILE类型结构体的指针变量
        if((read=fopen(filename,"r"))==NULL)   //以只读方式读取文件,如果为空执行下面的语句
    	{
    		printf("\n文件不存在,请确认好再输入!");
    		return -1;                     //跳出Read函数
    	}
    	while(!feof(read))          //feof()检测文件是否结束,到末尾函数值为“真”即非0
    	{
    		i=0;
    		ch=fgetc(read);         //读取一个字符
    		
    		
    		if (ch=='/')            //遇到‘/’就再读取一个字符
    		{
    			ch1=fgetc(read);
    			if(ch1=='/')           //遇到“//”注释
    				while(ch1!='\n')
    				{
    					ch1=fgetc(read);
    				}
    			else if (ch1=='*')    //遇见“/*”注释
    				{	
    					ch1=fgetc(read);
    					while(ch1!='*')
    					{
    						ch1=fgetc(read);
    						if(ch1=='*')
    						{
    							ch=fgetc(read);
    							if(ch=='/')
    								break;
    						}
    					}
    				
    				}
    			}
    		
    
    	
    
    		while(isLetter(ch)==0&&feof(read)==0)
    			ch=fgetc(read);     //如果不是字母就接着读取,关键字都是由字母组成的
    		while(isLetter(ch)==1&&feof(read)==0)
    		{
    			if(i==MAXLEN)
    			{
    				while(isLetter(ch)==1&&feof(read)==0)
    				{
    					ch=fgetc(read);       //超过MAXLEN的长度则一定不为关键字,把余下连一起的字母都读取
    				}
    				i=0;
    				break;
    			}
    
    			else
    			{
    				word[i++]=ch;             //把读取到的字母存入word数组中
    				ch=fgetc(read);
    			}
    		}
    		word[i]='\0';
    
    		if(isKeyWords(word))
    		{
    			CreatHX(word);
    		}
    	}
    	fclose(read);
    	printf("\n读取成功,文件中关键字已经存入hash表,请继续操作");
    }
    
    int isLetter(char ch) //判断是否是字母,因为关键字都是英文单词
    {
    	//if((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z'))
    	if((ch>='a'&&ch<='z'))
    		return 1;           //是字母就返回1
    	else
    		return 0;           //不是字母就返回0
    }
    
    
    int FindHX(char *keyword)   //查找哈希表,分块查找
    {
    	int key,find,tem=0;
    	if(!isKeyWords(keyword))    //用于查找制定关键字时判断是否为关键字
    		return -1;
    	key=GetKey(keyword);
    	if(strcmp(HS[key].keyword,keyword)==0)
    		return key;
    	for(find=key+1;find<HASHLEN;find++)
    	{                            //线性探查法顺序查找哈希表中是否已存在关键字
    		tem++;                   //统计冲突次数
    		if(strcmp(HS[find].keyword,keyword)==0)
    		{
    			HS[find].con=tem;        //若有相等的就把冲突的次数存入数组的con中
    			return find;
    		}
    	}
    	for(find=0;find<key;find++)   //后面的找不到再从前面开始找
    	{
    		tem++;
    		if(strcmp(HS[find].keyword,keyword)==0)
    		{
    			HS[find].con=tem;
    			return find;
    		}
    	}
    	return -1;
    }
    
    int CreatHX(char *keyword)     //建立哈希表,加个*是因为word是一个数组
    {
    	int key;
    	if(!isKeyWords(keyword))   //不是关键字跳出此函数
    		return -1;             
    	key=GetKey(keyword);       //计算哈希值,根据所给哈希函数计算得出的结果
    	if(strlen(HS[key].keyword)>0) //判断关键字表中该位置是否存在关键字,strlen用于计算()内的字符串长度
    	{      //已经存在有关键字
    		if(strcmp(HS[key].keyword,keyword)==0)
    		{  //再判断哈希表中该位置的关键字是否相同
    			HS[key].count++;               //相同就频度加1
    			return 1;                      //跳出函数
    		}
    		key=FindHX(keyword);  //不相同,继续查找
    		if(key<0)             //没有找到相等的keyword
    		{
    			key=GetFreePos(GetKey(keyword));
    			if(key<0)                 //哈希表满或者计算的哈希值有问题
    				return -1;
    			strcpy(HS[key].keyword,keyword);  //将关键字插入哈希表
    		}
    		if(key<0)
    			return -1;
    		HS[key].count++;
    	}
    	else  //该位置为空,直接将关键字插入该位置中
    	{
    		strcpy(HS[key].keyword,keyword);
    		HS[key].count++;
    	}
    	return 1;
    }
    
    int GetFreePos(int key)  //在哈希表中给关键字找个位置插进去
    {
    	int find,tem=0;
    	if(key<0||key>=HASHLEN)      
    		return -1;
    	for(find=key+1;find<HASHLEN;find++)  //先找后面的位置
    	{
    		tem++;
    		if(strlen(HS[find].keyword)==0)  //若这个地方为空
    		{
    		    HS[find].con=tem;            //把冲突的次数存入con中
    		    return find; 
    		}
    	}
    	for(find=0;find<key;find++)          //若后面没有地方可以插入,再找前面的位置
    	{
    		tem++;
    		if(strlen(HS[find].keyword)==0)
    		{
    			HS[find].con=tem;
    			return find;
    		}
    	}
    	return -1; //哈希表已满
    }
    
    void Show(int key)
    {
    	if(key<0||key>=HASHLEN)
    	{
    		printf("关键字不存在!\n");
    		return;
    	}
    	if(strlen(HS[key].keyword)==0)
    	{
    		printf("哈希表位置: %d  记录是空的!\n",key);
    		return;
    	}
    	printf("哈希表位置: %d   关键字: %-11s出现次数: %d\n",key,HS[key].keyword,HS[key].count);
    	cont++;
    }
    
    int GetKey(char *keyword)  //哈希函数
    {  //Hash函数为:Hash(Key)=[(Key的首字母序号)*100+(Key的尾字母序号)] Mod 41
    	return ( keyword[0]*100+keyword[strlen(keyword)-1] ) % 41; 
    }
    
    
    
    
    int isKeyWords(char *word)
    { int low,high,mid;
      low=0;high=M-1;
      while(low <= high)
      { mid=(low+high)/2;	
        if(strcmp(word,KeyWords[mid])==0) return(1);
    	if(strcmp(word,KeyWords[mid])==-1) high=mid-1;    
                              else low=mid+1;
      }
      return(0);
    }
    
    
    /*int isKeyWords(char *word)    //判断是否关键字
    {
    	int i;
    	for(i=0;i<TOTAL;i++)
    	if(strcmp(word,KeyWords[i])==0)
    		return 1; 
    	return 0;
    }*/

     
    展开全文
  • 哈希表查找详解

    2019-10-12 10:02:50
    哈希表查找又称散列表查找,通过查找关键字不需要比较就可以获得需要记录的存储位置,它是通过在记录的存储位置和它的关键字之间建立的一个确定的关系f,使得每个关键字key对应一个存储位置f(key)。即: –存储...

    哈希表查找

    • 定义
    • 基本概念

    1、定义

    哈希表查找又称散列表查找,通过查找关键字不需要比较就可以获得需要记录的存储位置,它是通过在记录的存储位置和它的关键字之间建立的一个确定的关系f,使得每个关键字key对应一个存储位置f(key)。即:
    –存储位置=f(关键字),其中f为哈希函数。

    1. 哈希表最适合的求解问题是查找与给定值相等的记录。
    2. 哈希查找不适合同样的关键字对应多条记录的情况,如使用关键字"男"去找找某个同学。
    3. 不适合范围查找,比如查找班级18~22岁的同学。

    2、基本概念

    • 1、哈希函数的构造方法

    怎么样的才算是好的哈希函数?
    1、计算简单。哈希函数的计算时间(指的是产生地址的时间),不应该超过其他查找技术与关键字比较的时间。
    2、地址分布均匀。尽量让哈希地址均匀分布在存储空间中,这样可以使空间有效的利用。
    

    (1)直接定址法
    我们可以去关键字的某个线性函数的值作为哈希地址,如下图所示
    在这里插入图片描述

    这种哈希函数优点是比较简单、匀称,也不会产生冲突,但是需要实现知道关键字的分布情况,适合查找表比较小且连续的情况。在实际中不常用。
    

    (2)数字分析法
    可以使用关键字的一部分来计算哈希存储的位置,比如手机号码的后几位(或者反转、左移右移等变换)。
    在这里插入图片描述
    通常适用于处理关键字位数比较大的情况,如果事先知道关键字的分布且关键字的若干位分布均匀,就可以考虑用这种方法。

    (3)除留余数法
    这是最为常用的构造哈希函数的方法,对于哈希表长度为m的哈希表函数为:
    在这里插入图片描述
    mod是取模(求余数)的意思。事实上,如果p选得不好,就很多容易出现同义冲突的情况:

    在这里插入图片描述
    如上图所示,选择p = 11,就会出现key = 12、144的冲突。

    根据经验,若哈希表表长为m,
    通常p为小于或者等于表长的最小质数或不包含小于20质因子的合数。
    (质数又称素数。是一个大于1的自然数,并且因数只有1和它自身,
    不能整除其他自然数。合数则因数除了1和本身还有其他因数的数。)
    
    • 2、哈希函数的构造方法

    从刚才的除留余数法可以看出,设计再好的哈希函数也不可能完全避免冲突(key1!=key2,但是f(key1 = f(key2))),下面介绍几种常用的避免冲突方法。
    

    (1)开放定址法
    该方法是一旦发生冲突,就去寻找下一个空的哈希表地址,只要哈希表足够大,空的哈希地址总能找到,并将其记录存入。
    在这里插入图片描述
    二次探测法:
    在这里插入图片描述
    增加平方项,主要是为了不让关键字都集中在某一块区域,避免不同的关键字争夺一个地址的情况。

    随机探测法:
    在这里插入图片描述
    di使用随机函数计算而来,是前面方法的改进。

    (2)链地址法
    在这里插入图片描述
    在这里插入图片描述
    如上图所示,取12位除数,进行除留余数法,无论存在多少冲突,都只是在当前位置给单链表增加节点而已。

    如上图所示,取12为除数,进行除留余数法,无论存在多少冲突,都只是在当前位置给单链表增加节点而已。

    展开全文
  • 详解哈希表查找

    万次阅读 多人点赞 2017-03-12 22:32:34
    哈希表查找又叫散列表查找,通过查找关键字不需要比较就可以获得需要记录的存储位置,它是通过在记录的存储位置和它的关键字之间建立一个确定的对应关系f,使得每个关键字key对应一个存储位置f(key)。即: —...

    哈希表查找

    • 定义
    • 基本概念
    • 实现方法

    1、定义

    哈希表查找又叫散列表查找,通过查找关键字不需要比较就可以获得需要记录的存储位置,它是通过在记录的存储位置和它的关键字之间建立一个确定的对应关系f,使得每个关键字key对应一个存储位置f(key)。即:
    —存储位置=f(关键字),其中f为哈希函数。

    1、哈希表最适合的求解问题是查找与给定值相等的记录。

    2、哈希查找不适合同样的关键字对应多条记录的情况,如使用关键字“男”去查找某个同学。

    3、不适合范围查找,比如查找班级18~22岁的同学。

    2、基本概念

    • 1、哈希函数的构造方法

    怎么样的才算是好的哈希函数?

    1、计算简单。哈希函数的计算时间(指的是产生地址的时间),不应该超过其他查找技术与关键字比较的时间。
    2、 地址分布均匀。尽量让哈希地址均匀分布在存储空间中,这样可以使空间有效的利用。

    (1)直接定址法

    我们可以去关键字的某个线性函数的值作为哈希地址,如下所示:

    f(key)= a*key + b (其中a,b均为常数)

    这种哈希函数优点是比较简单、均匀,也不会产生冲突,但是需要事先知道关键字的分布情况,适合查找表比较小且连续的情况。在实际中并不常用。

    (2)数字分析法

    可以使用关键字的一部分来计算哈希存储的位置,比如手机号码的后几位(或者反转、左移右移等变换)。

    这里写图片描述

    通常适用于处理关键字位数比较大的情况,如果事先知道关键字的分布且关键字的若干位分布均匀,就可以考虑用这种方法。

    (3)除留余数法

    这是最为常用的构造哈希函数的方法,对于哈希表长度为m的哈希函数为:

    f(key)=key mod p (p<=m)

    mod是取模(求余数)的意思。事实上,如果p选得不好,就很容易出现同义冲突的情况:

    这里写图片描述

    如上图所示,选择p=11,就会出现key=12、144的冲突。

    根据经验,若哈希表表长为m,通常p为小于或者等于表长的最小质数或不包含小于20质因子的合数。
    • 2、处理冲突的方法

    从刚才的除留余数法可以看出,设计再好的哈希函数也不可能完全避免冲突(key1!=key2,但是f(key1)=f(key2)),下面介绍几种常用的避免冲突方法。

    (1)开放定址法

    该方法是一旦发生冲突,就去寻找下一个空的哈希地址,只要哈希表足够大,空的哈希地址总能找到,并将其记录存入。

    fi(key)=(f(key)+di) mod m (di=1,2,3……m-1)

    二次探测法:

    fi(key)=(f(key)+di) mod m (di=1^2, -1^2, 2^2, -2^2……q^2, -q^2, q<=m/2)

    增加平方项,主要是为了不让关键字都集中在某一块区域,避免不同的关键字争夺一个地址的情况。

    随机探测法:

    fi(key)=(f(key)+di) mod m (di是一个随机数列)

    di使用随机函数计算而来,是前面方法的改进。

    (2)链地址法

    将所有关键字为同义词的记录存储在一个单链表中,在哈希表中只存所有同义词子表的指针。

    这里写图片描述

    如上图所示,取12为除数,进行除留余数法,无论存在多少冲突,都只是在当前位置给单链表增加节点而已。

    3、实现方法

    • 1、首先定义一些哈希表的结构,以及一些相关的常数。
    #define SUCCESS 1
    #define UNSUCCESS 0
    #define HASHSIZE 12  //定义哈希表长为数组的长度
    #define NULLKEY -32768
    typedef struct
    {
        int *elem;  //数据元素存储的基址,动态分配数组
        int count;
    
    }HashTable;
    int m = 0;
    • 2、对哈希表进行初始化
    Status InitHashTable(HashTable *H)
    {
        int i;
        m = HASHSIZE;
        H->count = m;
        H->elem = (int *)malloc(m*sizeof(int));
        for (i = 0; i < m; i++)
            H->elem[i] = NULLKEY;
        return OK;
    
    }
    • 3、定义哈希函数(为插入时计算地址),这里可以根据不同的情况更换算法
    int Hash(int key)
    {
        return key % m; //这里使用的是除留余数法
    }
    • 4、对哈希表进行插入操作
    void InsertHash(HashTable *H, int key)
    {
        int addr = Hash(key); //根据关键字求取地址
        while (H->elem[addr] != NULLKEY) //如果不为空,有冲突出现
            addr = (addr + 1) % m; //这里使用开放定址法的线性探测
    
        H->elem[addr] = key; //直到有空位后插入
    }
    • 5、通过哈希表进行关键字的查找过程,如下所示
    Status SearchHash(HashTable H, int key, int *addr)
    {
        *addr = Hash(key);  //求取哈希地址
        while (H.elem[*addr] != key) //如果不为空,则存在冲突
        {
            *addr = (*addr + 1) % m;  //开发定址法的线性探测
    
            if (H.elem[*addr] == NULLKEY || *addr == Hash(key))
                return UNSUCCESS; //关键字不存在
        }
        return SUCCESS; //查找成功返回
    }
    展开全文
  • 哈希表查找

    2013-08-25 16:21:16
    用户从键盘输入若干个()个关键字,程序建立哈希表。然后用户键入一个关键字,程序在哈希表查找,若找到则输出该元素在表中的位置下标,若找到则输出“没有查找到”的信息。
  • 哈希表查找不成功时的平均查找长度计算和查找成功时的ASL 例如: 关键字集合   { 19, 01, 23, 14, 55, 68, 11, 82, 36 } 设定哈希函数 H(key) = key MOD 11 ( 表长=11 ) 查找成功次数: 1 ...

    哈希表查找不成功时的平均查找长度计算和查找成功时的ASL

    例如:  关键字集合 
            { 19, 01, 23, 14, 55, 68, 11, 82, 36 }

    设定哈希函数 H(key) = key MOD 11 ( 表长=11 )


    查找成功次数:    1      1    2     1    3    6     2       5     1

    查找不成功次数:10    9     8    7    6    5     4       3      2    1    1

    查找成功时的平均查找长度:ASL=(1+1+2+1+3+6+2+5+1)/9=22/9
    查找不成功时的平均查找长度:ASL=(10+9+8+7+6+5+4+3+2+1+1)/11=56/11
    说明:
    第n个位置不成功时的比较次数为,第n个位置到第1个没有数据位置的距离。
      如:第0个位置到第1个没有数据位置(9)的距离为10!





    展开全文
  • 七大查找算法之哈希表查找

    千次阅读 2018-10-21 17:10:34
     哈希表查找又叫散列表查找,通过查找关键字不需要比较就可以获得需要记录的存储位置,它是通过在记录的存储位置和它的关键字之间建立一个确定的对应关系f,使得每个 key 对应一个存储位置 f...
  • 首先,推荐两个写的很好的关于哈希表查找——成功和成功时的平均查找长度的博客,感谢分享! https://blog.csdn.net/longlovefilm/article/details/78009782 ... 尤其需要注意哈希表查找不成功时的平均查找长度。...
  • 查找算法:哈希算法哈希表查找哈希表的定义例如:那么问题来了,如果集合S中同时存在值K=16和值K=27,我们该如何将两个地址一样的值存入哈希表呢?常用的哈希函数1. 除留余数法(m为表长,p为小于m的最大素数)H(key)...
  • 1. 哈希表的概念 对于动态查找表而言,1) 表长确定;2)在设计查找表时,只知道关键字所属范围,而知道确切的关键字。因此,一般情况需建立一个函数关系,以f(key)作为关键字为key的录在表中的位置,通常称这个...
  • 哈希表查找不成功的ASL问题

    万次阅读 多人点赞 2017-10-24 23:07:31
    哈希表(等概率情况下)查找成功与查找不成功的平均查找长度计算问题,迷惑了好一会,在这里总结下来:  首先,你要明白的是平均查找长度求的是期望,那么你就按照求期望的方法来求平均查找长度吧,千万记着...
  • 接下来讨论成功的情况, 看2,计算查找不成功的次数就直接找关键字到第一个地址上关键字为空的距离即可, 但根据哈希函数地址为MOD7,因此初始只可能在06的位置。等概率情况下,查找06位置查找失败的查找次数为:...
  • 最近复习数据结构中的哈希表,发现在计算等概率情况下查找不成功的平均查找长度时太理解,知道到底是怎么计算出来的。看了几篇博客后终于知道如何计算了,总结如下。 例题: 将关键字序列(7、8、30、11、...
  • 1. 哈希表的概念  对于动态查找表而言,1) 表长确定;2)在设计查找表时,只知道关键字所属范围,而知道确切的关键字。因此,一般情况需建立一个函数关系,以f(key)作为关键字为key的录在表中的位置,通常称这...
  • 哈希表查找、哈希冲突-面试题

    千次阅读 2016-08-30 00:13:49
    哈希查找是面试中常见的问题。本文为自己梳理一下知识点。 对于大多数查找算法,其查找...这就是哈希表查找。哈希查找特别适用于集合元素无明显关系的集合。哈希表哈希存储的基本思想是以关键字(key)为自变量,通过
  • 数据结构实验4.2 链式哈希表查找

    千次阅读 2009-12-26 19:50:00
     程序应包含的主要功能函数有: Hash( ):计算哈希地址 InitialHash( ):初始化哈希表SearchHash( ):在哈希表查找关键字InsertHash( ):向哈希表中插入关键字DeleteHash( ):删除哈希表中某一关键字PrintHash ...
  • 输入一组名字至少50个将其保存并利用哈希表查找输出哈希查找冲突次数哈希表负载因子查找命中率 数据结构 哈希表和数组二维二维数组用于静态顺序存储名字字符串哈希表采用开放定址法用于存储名字字符串对应的关键字并...
  • 哈希表查找方法简集

    2019-02-27 10:43:21
    1、哈希表查找介绍 哈希表的代码实现 我之前介绍两种方向的查找算法: 静态查找算法(折半查找、插值查找、斐波那契查找、分块查找) 动态查找算法(二叉排序树、平衡二叉树、B-树、B+树) 但是,这些查找算法都是...
  • 如何计算哈希表查找失败时的平均查找长度

    万次阅读 多人点赞 2020-04-30 18:20:01
    1.请回答采用线性探测再散列和链地址法处理冲突构建的哈希表中,查找失败时的平均查找长度如何计算? 例:已知一组关键字(19,14,23,1,68,20,84,27,55,11,10,79) 哈希函数为:H(key)=keyMOD13,哈希表长为m=15,设每个记录...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,309
精华内容 19,723
关键字:

哈希表查找不存在的关键字