DS哈希查找—二次探测再散列

题目描述

定义哈希函数为H(key) = key%11。输入表长(大于、等于11),输入关键字集合,用二次探测再散列构建哈希表,并查找给定关键字。

输入

测试次数t

每组测试数据格式如下:

哈希表长m、关键字个数n

n个关键字

查找次数k

k个待查关键字

输出

对每组测试数据,输出以下信息:

构造的哈希表信息,数组中没有关键字的位置输出NULL

对k个待查关键字,分别输出:

0或1(0—不成功,1—成功)、比较次数、查找成功的位置(从1开始)

样例输入

1 12 10 22 19 21 8 9 30 33 4 41 13 4 22 15 30 41

样例输出

22 9 13 NULL 4 41 NULL 30 19 8 21 33 1 1 1 0 3 1 3 8 1 6 6

提示

#include<iostream>
using namespace std;
#define INF -9999
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        int m,n;
        cin>>m>>n;
        int *array=new int[m];
        for(int i=0;i<m;i++)
            array[i]=INF;
        for(int i=0;i<n;i++)
        {
            int num;
            cin>>num;
            if(array[num%11]==INF)
            {
                array[num%11]=num;
            }
            else
            {
                int di=0;
                int oper1=0;
                int oper2=0;
                while(true)
                {
                    oper1=di*di;
                    oper2=-di*di;
                    while(oper1>m)
                    {
                        oper1-=m;
                    }
                    while(oper2<0)
                    {
                        oper2+=m;
                    }
                    if(array[(num%11+oper1)%m]==INF)
                    {
                        array[(num%11+oper1)%m]=num;
                        break;
                    }
                    else if(array[(num%11+oper2)%m]==INF)
                    {
                        array[(num%11+oper2)%m]=num;
                        break;
                    }
                    else
                        di++;
                }
            }
        }
        for(int i=0;i<m;i++)
        {
            if(array[i]!=INF)
                cout<<array[i];
            else
                cout<<"NULL";
            if(i!=m-1)
                cout<<" ";
        }
        cout<<endl;

        int K;
        cin>>K;
        while(K--)
        {
            int di=0;
            int oper1=0;
            int oper2=0;
            int C;
            cin>>C;
            int times=0;
            while(true)
            {
                oper1=di*di;
                oper2=-di*di;
                while(oper1>m)
                    oper1-=m;
                while(oper2<0)
                    oper2+=m;
                times++;
                if(array[(C%11+oper1)%m]==C)
                {
                    cout<<"1"<<" "<<times<<" "<<(C%11+oper1)%m+1<<endl;
                    break;
                }
                if(di==0)
                {
                    di++;
                    continue;
                }
                times++;
                if(array[(C%11+oper2)%m]==C)
                {
                    cout<<"1"<<" "<<times<<" "<<(C%11+oper2)%m+1<<endl;
                    break;
                }
                if(di==m||array[(C%11+oper1)%m]==INF||array[(C%11+oper2)%m]==INF)
                {
                    cout<<"0"<<" "<<times<<endl;
                    break;
                }
                else
                    di++;
            }
        }
        delete []array;
    }
    return 0;
}

原文地址:https://www.cnblogs.com/SZU-DS-wys/p/12183048.html

时间: 2024-10-30 08:46:15

DS哈希查找—二次探测再散列的相关文章

线性探测再散列 建立HASH表

根据数据元素的关键字和哈希函数建立哈希表并初始化哈希表,用开放定址法处理冲突,按屏幕输出的功能表选择所需的功能实现用哈希表对数据元素的插入,显示,查找,删除. 初始化哈希表时把elem[MAXSIZE].elemflag[MAXSIZE]和count分别置0.创建哈希表时按哈希函数创建哈希表,输入数据元素的关键字时,以“0”结束输入且要求关键字为正整数,数据元素个数不允许超过表长MAXSIZE. 输出的形式:根据所选择的哈希表的功能输出相应提示语句和正确结果. 程序的功能:将一组个数不超过哈希表

哈希表---线性探测再散列(hash)

//哈希表---线性探测再散列 #include <iostream> #include <string> #include <stdio.h> #include <string.h> #define m 10000 #define NULLkey -1 using namespace std; int HashTable[m]; int Hash_search( int k) { int p0, pi; p0=hash(k); //函数运算值 if(Has

哈希查找解决地址冲突的两种最常见方法(线性探测再散列,链地址法)C++实现

#include<iostream>#include<iomanip>using namespace std; typedef struct Node{ int data; struct Node *next;}node; int len,num,M,numbers,i=0,mod,count=0;int *a;node **p,*s;float ASL=0,ASL1=0; int ListLength(node * head){ int length=0; node *p; p=

散列&#183;再散列

目录 再散列 1.定义 2.图解 再散列 1.定义 ? 当散列表的内容达到装填因子\(\lambda\)时,散列表需要进行扩容.扩容后形成新的散列表,将原散列表的值再散列到新的散列表,这个过程叫做再散列. 2.图解 2.1 图解说明 ? 在大小为7的散列表图1中,我们再插入23,此时\(\lambda\)达到上限.我们需要对散列表进行扩展.扩展的大小选择的是原大小的2倍之后的第一个素数.然后我们需要将原来的值,再次散列到新的散列表中,得到图3. 原文地址:https://www.cnblogs.

哈希冲突的处理【闭散列方法-线性探测和二次探测】

散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构.也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度.这个映射函数叫做散列函数,存放记录的数组叫做散列表. 给定表M,存在函数Hash(key),对任意给定的关键字值key,代入函数后若能得到包含该关键字的记录在表中的地址,则称表M为哈希(Hash)表,函数Hash(key)为哈希(Hash) 函数. 构造哈希表的两种方法 1.直接定址法--取关键字的某个线性函数为散列地

哈希查找

除留余数法与开放定址法构建哈希表: 定义哈希表类型: typedef datatype{ int key; int hi;   //表示本该存储的位置到最后存储的位置的冲突次数 } typedef HashTable{ datatype *base; //指向表的指针 int length; //表长 int num;   //表内元素个数 }hashtable;   //哈希表 void createhashtable(hashtable H,int m,hash[]){   //m为表长,h

例27:哈希查找

哈希查找本身听着很是高端,然后呢,听着感觉很难的样子,但是其原理也是非常简单,其实他的意思就是说通过一个函数,直接把值的地址与值本身之间关联起来,成为一个地址 = F(值)的函数,所以这种方式的查找速度为O(1),是一种很快的查找方式. 1.在查找之前首先先建立哈希表,其实就是按照 地址=F(值) 函数给出值所应存储的地址.常用的哈希函数有五种:直接定址法,除数取余法,数字分析法,平方取中法,折叠法.具体方法此处不详细介绍了,读者可以上网搜索一下,很多介绍很详细的. 2.如果此地址已经保存了某个

数据结构-散列查找

判断题 1.将M个元素存入用长度为S的数组表示的散列表,则该表的装填因子为M/S. T      F 2.在散列中,函数"插入"和"查找"具有同样的时间复杂度. T      F 3.在散列表中,所谓同义词就是被不同散列函数映射到同一地址的两个元素. T      F 4.采用平方探测冲突解决策略(hi(k)=(H(k)+i2)%11, 注意:不是±i2),将一批散列值均等于2的对象连续插入一个大小为11的散列表中,那么第4个对象一定位于下标为0的位置. T    

查找之散列查找(哈希表)

本学习笔记部分内容来自网易云课堂浙江大学数据结构课程,谢谢! 1.散列表(哈希表) 已知的几种查找方法: 顺序查找  O(N) 二分查找(静态查找)  O(logN) 二叉搜索树      O(h)  h为二叉树高度   (动态查找:有插入有删除有查找) 平衡二叉树      O(logN) 查找的本质:已知对象找位置 1.有序安排对象:全序或半序: 2.直接算出对象位置:散列. 散列查找法的两项基本工作: 1.计算位置:构造散列函数确定关键词存储位置: 2.解决冲突:应用某种策略解决多个关键词