数据结构OJ实验14-哈希查找

最新推荐文章于 2024-05-31 19:04:21 发布
最新推荐文章于 2024-05-31 19:04:21 发布
阅读量1k 收藏 19
点赞数 26
分类专栏： 算法学习 C++学习 OJ 文章标签： 数据结构 哈希算法 散列表 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gyeolhada/article/details/135346656
版权
算法学习 同时被 3 个专栏收录
31 篇文章 12 订阅
订阅专栏
C++学习
31 篇文章 6 订阅
订阅专栏
OJ
16 篇文章 0 订阅
订阅专栏

A. DS哈希查找—线性探测再散列

题目描述

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

输入

测试次数t

每组测试数据为：

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

n个关键字

查找次数k

k个待查关键字

输出

对每组测试数据，输出以下信息：

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

对k个待查关键字，分别输出：0或1（0—不成功，1—成功）、比较次数、查找成功的位置（从1开始）

样例查看模式 

正常显示查看格式

输入样例1 

1\n
12 10\n
22 19 21 8 9 30 33 4 15 14\n
4\n
22\n
56\n
30\n
17\n

输出样例1

22 30 33 14 4 15 NULL NULL 19 8 21 9\n
1 1 1\n
0 6\n
1 6 2\n
0 1\n

AC代码

#include<bits/stdc++.h>
using namespace std;
const int N=1e5;
int n,m;
int h[N];
int k;
void hasht(int x)
{
    int x1=x%11;//初始
    for(int i=0;i<m;i++)
    {
        int temp=(x1+i)%m;//再线性探测
        if(h[temp]==-1)
        {
            h[temp]=x;
            break;
        }
    }
}
void find(int x)
{
    int cnt=0;
    int idx=-1;
    bool ok=0;
    int x1=x%11;
    for(int i=0;i<m;i++)
    {
        cnt++;//查找次数
        int temp=(x1+i)%m;
        if(h[temp]==-1)
        {
            break;//找不到这个元素
        }
        if(h[temp]==x)
        {
            ok=1;
            idx=temp;
            break;
        }
    }
    if (ok)
			cout << ok << " " << cnt << " " << idx + 1 << endl;
		else
			cout << ok << " " << cnt << endl;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
       memset(h,-1,sizeof(h));//初始h
       cin>>m>>n;
       for(int i=0;i<n;i++)
       {
          int x;
          cin>>x;
          hasht(x);
       }
       for(int i=0;i<m;i++)
       {
        if(h[i]!=-1)
        {
            cout<<h[i];
        }
        else cout<<"NULL";
        if(i!=m-1)cout<<" ";
        else cout<<endl;
       }
       cin>>k;
       while(k--)
       {
        int x;
        cin>>x;
        find(x);
       }
    }
    return 0;
}

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

题目描述

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

输入

测试次数t

每组测试数据格式如下：

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

n个关键字

查找次数k

k个待查关键字

输出

对每组测试数据，输出以下信息：

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

对k个待查关键字，分别输出：

0或1（0—不成功，1—成功）、比较次数、查找成功的位置（从1开始）

样例查看模式 

正常显示查看格式

输入样例1 

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

输出样例1

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

AC代码

#include<bits/stdc++.h>
using namespace std;
const int N=1e5;
int m,n,t,k;
int h[N];
int d[N];
void init()
{
   d[0]=0;
   memset(d,0,sizeof(d));
   for(int i=1;i<m;i++)
   {
       if(i%2)
       {
        d[i]=pow((i+1)/2,2);
       }
       else
       {
        d[i]=-d[i-1];
       }
   }
}
void hasht(int x)
{
    int x1=x%11;
    for(int i=0;i<m;i++)
    {
        int temp=(x1+d[i]+m)%m;
        if(h[temp]==-1)
        {
            h[temp]=x;
            break;
        }
    }
}
void find(int x)
{
    int cnt=0;
    int idx=-1;
    bool ok=0;
    int x1=x%11;
    for(int i=0;i<m;i++)
    {
        cnt++;
        int temp=(x1+d[i]+m)%m;
        if(h[temp]==-1)break;
        if(h[temp]==x)
        {
            ok=1;
            idx=temp;
            break;
        }
    }
    if (ok)
			cout << ok << " " << cnt << " " << idx + 1 << endl;
	else
			cout << ok << " " << cnt << endl;
}
int main()
{
    cin>>t;
    while(t--)
    {
        cin>>m>>n;
        init();
        memset(h,-1,sizeof(h));
        for(int i=0;i<n;i++)
        {
            int x;
            cin>>x;
            hasht(x);
        }
        for(int i=0;i<m;i++)
       {
        if(h[i]!=-1)
        {
            cout<<h[i];
        }
        else cout<<"NULL";
        if(i!=m-1)cout<<" ";
        else cout<<endl;
       }
        cin>>k;
        while(k--)
        {
            int x;
            cin>>x;
            find(x);
        }
    }
    return 0;
}

C. DS哈希查找--链地址法(表头插入)

题目描述

给出一个数据序列，建立哈希表，采用求余法作为哈希函数，模数为11，哈希冲突用链地址法和表头插入

如果首次查找失败，就把数据插入到相应的位置中

实现哈希查找功能

输入

第一行输入n，表示有n个数据
第二行输入n个数据，都是自然数且互不相同，数据之间用空格隔开
第三行输入t，表示要查找t个数据
从第四行起，每行输入一个要查找的数据，都是正整数

输出

每行输出对应数据的查找结果

样例查看模式 

正常显示查看格式

输入样例1 

6\n
11 23 39 48 75 62\n
6\n
39\n
52\n
52\n
63\n
63\n
52\n

输出样例1

6 1\n
error\n
8 1\n
error\n
8 1\n
8 2\n

AC代码

#include<bits/stdc++.h>
using namespace std;
list<int>l[11];
map<int,int>mp;
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        int x;
        cin>>x;
        l[x%11].push_front(x);
        mp[x]=1;
    }
    int k;
    cin>>k;
    while(k--)
    {
        int x;
        cin>>x;
        int d=x%11;
        if(mp[x]==0)
        {
            l[d].push_front(x);
            mp[x]=1;
            cout<<"error"<<endl;
        }
        else
        {
            cout<<d<<" ";
            int idx=0;
            for(auto t:l[d])
            {
                idx++;
                if(t==x)
                {
                    break;
                }
            }
            cout<<idx<<endl;
        }
    }
    return 0;
}

D. DS哈希查找与增补（表尾插入）

题目描述

给出一个数据序列，建立哈希表，采用求余法作为哈希函数，模数为11，哈希冲突用链地址法和表尾插入

如果首次查找失败，就把数据插入到相应的位置中

实现哈希查找与增补功能

输入

第一行输入n，表示有n个数据
第二行输入n个数据，都是自然数且互不相同，数据之间用空格隔开
第三行输入t，表示要查找t个数据
从第四行起，每行输入一个要查找的数据，都是正整数

输出

每行输出对应数据的查找结果，每个结果表示为数据所在位置[0，11）和查找次数，中间用空格分开

样例查看模式 

正常显示查看格式

输入样例1 

6\n
11 23 39 48 75 62\n
6\n
39\n
52\n
52\n
63\n
63\n
52

输出样例1

6 1\n
error\n
8 1\n
error\n
8 2\n
8 1

AC代码

#include<bits/stdc++.h>
using namespace std;
map<int,int>mp;
list<int>l[11];
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        int x;
        cin>>x;
        mp[x]=1;
        l[x%11].push_back(x);
    }
    int k;
    cin>>k;
    while(k--)
    {
        int x;
        cin>>x;
        int d=x%11;
        if(mp[x]==0)
        {
            mp[x]=1;
            l[d].push_back(x);
            cout<<"error"<<endl;
        }
        else
        {
            int idx=0;
            cout<<d<<" ";
            for(auto t:l[d])
            {
                idx++;
                if(t==x)
                {
                    break;
                }
            }
            cout<<idx<<endl;
        }
    }
    return 0;
}

E. DS哈希查找--Trie树

题目描述

Trie树又称单词查找树，是一种树形结构，如下图所示。

它是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来节约存储空间，最大限度地减少无谓的字符串比较，查询效率比哈希表高。

输入的一组单词，创建Trie树。输入字符串，计算以该字符串为公共前缀的单词数。

（提示：树结点有26个指针，指向单词的下一字母结点。）

输入

测试数据有多组

每组测试数据格式为：

第一行：一行单词，单词全小写字母，且单词不会重复，单词的长度不超过10

第二行：测试公共前缀字符串数量t

后跟t行，每行一个字符串

输出

每组测试数据输出格式为：

第一行：创建的Trie树的层次遍历结果

第2~t+1行：对每行字符串，输出树中以该字符串为公共前缀的单词数。

样例查看模式 

正常显示查看格式

输入样例1 

abcd abd bcd efg hig\n
3\n
ab\n
bc\n
abcde

输出样例1

abehbcficddggd\n
2\n
1\n
0

AC代码

#include<bits/stdc++.h>
using namespace std;
int sum=0;
int n;
class tri
{
public:
    bool flag=0;
    tri* next[26]={nullptr};

    void insertt(string s)
    {
        tri* node=this;
        for(int i=0;i<s.size();i++)
        {
            char c=s[i];
            if(node->next[c-'a']==nullptr)
            {
                node->next[c-'a']=new tri();
            }
            node=node->next[c-'a'];
        }
        node->flag=1;
    }

    int find(string pre)
    {
        tri* node=this;
        sum=0;
        for(int i=0;i<pre.size();i++)
        {
            char c=pre[i];
            if(node->next[c-'a']==nullptr)return 0;
            node=node->next[c-'a'];
        }
        dfs(node);
        return sum;
    }

    void dfs(tri* node)
    {
        tri* tr=new tri();
        tr=node;
        int tt=0;
        for(int i=0;i<26;i++)
        {
            if(tr->next[i])
            {
                dfs(tr->next[i]);
                tt=1;
            }
        }
        if(tt==0)
        {
            sum++;
            return;
        }
    }

    void bfs()
    {
        tri *node=new tri();
        node=this;
         queue<tri*>q;
         q.push(node);
         while(!q.empty())
         {
            tri *t=q.front();
            q.pop();
            for(int i=0;i<26;i++)
            {
                if(t->next[i])
                {
                    cout<<char('a'+i);
                    q.push(t->next[i]);
                }
            }
         }
    }
};
int main()
{
    tri *tree=new tri();
    string s;
    getline(cin,s);
    string k="";
    for(int i=0;i<s.size();i++)
    {
        if(s[i]!=' ')
        {
           k+=s[i];
           if(i==s.size()-1)
           {
             tree->insertt(k);
            k.clear();
           }
        }
        else 
        {
            tree->insertt(k);
            k.clear();
        }
    }
    tree->bfs();
    cout<<endl;
    cin>>n;
    while(n--)
    {
        string rr;
        cin>>rr;
        cout<<tree->find(rr)<<endl;
    }
    return 0;
}

F. 逆散列问题

题目描述

给定长度为 N 的散列表，处理整数最常用的散列映射是 H(x)=x%N。如果我们决定用线性探测解决冲突问题，则给定一个顺序输入的整数序列后，我们可以很容易得到这些整数在散列表中的分布。例如我们将 1、2、3 顺序插入长度为 3 的散列表HT[]后，将得到HT[0]=3，HT[1]=1，HT[2]=2的结果。

但是现在要求解决的是“逆散列问题”，即给定整数在散列表中的分布，问这些整数是按什么顺序插入的？

输入

输入的第一行是正整数 N（≤1000），为散列表的长度。第二行给出了 N 个整数，其间用空格分隔，每个整数在序列中的位置（第一个数位置为0）即是其在散列表中的位置，其中负数表示表中该位置没有元素。题目保证表中的非负整数是各不相同的。

输出

按照插入的顺序输出这些整数，其间用空格分隔，行首尾不能有多余的空格。注意：对应同一种分布结果，插入顺序有可能不唯一。例如按照顺序 3、2、1 插入长度为 3 的散列表，我们会得到跟 1、2、3 顺序插入一样的结果。在此规定：当前的插入有多种选择时，必须选择最小的数字，这样就保证了最终输出结果的唯一性。

样例查看模式 

正常显示查看格式

输入样例1

11\n
33 1 13 12 34 38 27 22 32 -1 21

输出样例1

1 13 12 21 33 34 38 27 22 32

AC代码

#include<bits/stdc++.h>
using namespace std;
const int N=1e5;
struct key
{
    int data;
    int fact;
    int suppose;
    key(){}
    key(int d,int i,int n)
    {
        data=d;
        fact=i;
        suppose=d%n;
    }
};
int h[N];
key kk[N];
int st[N];
bool cmp(key a,key b)
{
	return a.data<b.data;
}
int main(){
	int n;
	cin>>n;
	int m=0; 
	for(int i=0;i<n;i++)
    {
		cin>>h[i];
		if(h[i]==-1) st[i]=1;	
		else
        {
			kk[m]=key(h[i],i,n);
			m++; 
		} 
	}
	sort(kk,kk+m,cmp);
	while(1)
    {
		int flag=0;
		for(int i=0;i<m;i++)
        {
			if(kk[i].fact==kk[i].suppose&&st[kk[i].fact]==0){
				cout<<kk[i].data<<" ";
				st[kk[i].fact]=1;
				break;
			}
			int tag=1;
			int d=kk[i].fact-kk[i].suppose;
			if(d<0) d=d+n;
			for(int j=kk[i].suppose,k=0;k<d;j++,k++)
            {
				
				if(st[j%n]==0)
                {
					tag=0;
				}
			}
			if(tag==1&&st[kk[i].fact]==0)
            {
				cout<<kk[i].data<<" ";
				st[kk[i].fact]=1;
				break;
			}
		}
		for(int i=0;i<n;i++){
			if(st[i]==0){
				flag=1;
			}
		
		}
		if(flag==0) break;
	}
	return 0;	
}

起床悠悠
关注
  • 26
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
leetcode和oj-Data-Structures-and-Algorithms:数据结构与算法
06-30
基本数据结构和算法 这些算法全部自己敲一遍： 动态数组 链表 双向链表 栈 队列 树 二叉树 二叉查找树 伸展树(splay tree 分裂树) 平衡二叉树AVL 红黑树 B树,B+,B* R树 Trie树(前缀树) 后缀树 最优二叉树(赫夫曼树) ...
Java数据结构与算法，笔试题，OJ.zip
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
2020秋数据结构实验第五题：哈希查找 C++实现
USTC暖暖的博客
12-09 420
实验描述： 实验分析： 所谓哈希查找也就是根据输入的数据找到我们想要查找的信息，而且要做到O(1)的时间复杂度，即并不随着数据量的变大而查找次数变得很大，基础哈希表的创建过程如下： 根据输入计算Hash值，如果不冲突直接放入对应的槽中； 如果冲突可以采用几种冲突解决的方法进行解决，开放地址法和链式存储法，现在本助教给出开放地址法中的再Hash的方法进行解决冲突； 通过1和2已经创建了Hash表，我们再创建的时候记录冲突最大的次数，也将是我们在查找时的最大查找次数，进行查找，计算平均查找次数。
15-A. DS哈希查找--链地址法
bianchengfive的博客
12-22 761
实验15-哈希查找与排序- 题目描述 给出一个数据序列，建立哈希表，采用求余法作为哈希函数，模数为11，哈希冲突用链地址法和表头插入 如果首次查找失败，就把数据插入到相应的位置中 实现哈希查找功能 输入 第一行输入n，表示有n个数据 第二行输入n个数据，都是自然数且互不相同，数据之间用空格隔开 第三行输入t，表示要查找t个数据 从第四行起，每行输入一个要查找的数据，都是正整数 输出 每行输出对应数据的查找结果 输入样例 6 11 23 39 48 75 62 6 39 52 52 63 63 52 输出样例
数据结构实验之查找七：线性之哈希表(SDUT OJ3379)
weixin_45832594的博客
04-16 254
E - 数据结构实验之查找七：线性之哈希表Description根据给定的一系列整数关键字和素数p,用除留余数法定义hash函数H(Key)=Key%p,将关键字映射到长度为p的哈希表中，用线性探测法解决冲突。重复关键字放在hash表中的同一位置。 Input连续输入多组数据，每组输入数据第一行为两个正整数N(N <= 1500)和p(p >= N的最小素数)，N是关键字总数，p是ha...
数据结构实验之查找五：平方之哈希表
Just like myself.
12-13 396
数据结构实验之查找五：平方之哈希表 Time Limit: 400MS Memory Limit: 65536KB Submit Statistic Problem Description 给定的一组无重复数据的正整数，根据给定的哈希函数建立其对应hash表，哈希函数是H(Key)=Key%P，P是哈希表表长，P是素数，处理冲突的方法采用平方探测方法，增量di=±i^2,i
SDUT OJ 3377数据结构实验之查找五：平方之哈希表
公子世无双的博客
08-23 416
数据结构实验之查找五：平方之哈希表 Time Limit: 400MS Memory limit: 65536K 题目描述 给定的一组无重复数据的正整数，根据给定的哈希函数建立其对应hash表，哈希函数是H(Key)=Key%P，P是哈希表表长，P是素数，处理冲突的方法采用平方探测方法，增量di=±i^2,i=1,2,3,...,m-1 输入
SCAU_OJ 8622 哈希查找
Rayzihao的博客
03-27 1868
8622 哈希查找 时间限制:1000MS 代码长度限制:10KB 提交次数:2013 通过次数:1250 题型: 编程题 语言: G++;GCC Description 使用哈希函数：H(k)=3*k MOD length，并采用开放定址法处理冲突。试对输入的关键字序列构造哈希表，哈希表长度为length，求等概率情况下查找成功的平均查找长度，并设计构造哈希表的完整的算法。本题给出部分代码，请补全Hash函数和解决冲突的collison函数。 #include"malloc.h" /* malloc
数据结构-基础-逻辑结构-线性结构（线性表）-顺序表-链表-栈-队列-数组-哈希表-广义表-
LXMXHJ的博客
06-21 669
数据结构：基础-线性表； 顺序表、链表；栈、队列；数组、哈希表、广义表；
数据结构实验之查找五：平方之哈希表 sdut oj 3377
rain_snowing的博客
08-22 341
查找&&哈希
数据结构实验之查找七：线性之哈希表
Just like myself.
12-13 305
数据结构实验之查找七：线性之哈希表 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 根据给定的一系列整数关键字和素数p,用除留余数法定义hash函数H(Key)=Key%p,将关键字映射到长度为p的哈希表中，用线性探测法解决冲突。重复关键字放在hash表中的同一位置。
leetcode和oj-Learn-Algorithms:学习算法
06-30
基本数据结构和算法 这些算法全部自己敲一遍： 链表 链表 双向链表 哈希表/散列表 (Hash Table) 散列函数 碰撞解决 字符串算法 排序 查找 BF算法 KMP算法 BM算法 正则表达式 数据压缩 二叉树 二叉树 二叉查找树 伸展...
leetcode和oj-Algorithms:算法
06-30
基本数据结构和算法 这些算法全部自己敲一遍： 链表 链表 双向链表 哈希表/散列表 (Hash Table) 散列函数 碰撞解决 字符串算法 排序 查找 BF算法 KMP算法 BM算法 正则表达式 数据压缩 二叉树 二叉树 二叉查找树 伸展...
高级数据结构-树状数组
weixin_72982195的博客
05-29 423
基本知识：1.lowbit运算2.树状数组及其应用a[N]是原始数组；c[N]是树状数组，存放数组a中i号位之前的lowbit(i)个元素之和，c[i]覆盖长度是lowbit(i)特别强调 树状数组的下标必须从1开始！！！（1）.函数getSum(x)，返回前x个数之和a[1]+a[2]+......a[x].（2）.函数update(x,c).实现将第x个数加上一个数v的功能，即a[x] += c；例题1：在完成了分配任务之后，西部 314来到了楼兰古城的西部。
数据结构--链表
pzn2506的博客
05-30 1273
想象⼀下这样的场景，假设每节⻋厢的⻋⻔都是锁上的状 态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从⻋头⾛到⻋尾？链表的结构跟⽕⻋⻋厢相似，淡季时⻋次的⻋厢会相应减少，旺季时⻋次的⻋厢会额外增加⼏节。链表中每个节点都是独⽴申请的（即需要插⼊数据时才去申请⼀块节点的空间），我们需要通过指针变量来保存下⼀个节点位置才能从当前节点找到下⼀个节点。当我们想要从第⼀个节点⾛到最后⼀个节点时，只需要在前⼀个节点拿上下⼀个节点的地址（下⼀个节点的。最简单的做法：每节⻋厢⾥都放⼀把下⼀节⻋厢的钥匙。
数据结构--拓扑排序
最新发布
Zhang_Qin123的博客
05-31 558
对于一个进行拓扑排序，是将G中所有节点排成一个线性序列，该序列满足以下两个条件：① 每个节点有且仅出现一次 ② 若存在一条从节点A到节点B的路径，则在序列中A一定出现在B前面。对于求一个有向无环图的拓扑排序步骤：1.在图中找到一个没有前驱(入度为0)的节点，然后输出2. 从图中删除该节点和所有以它为起点的有向边3.重复操作1和操作2，直到图为空 或 当前图不存在无前驱的顶点为止第一步操作，删除节点 1第二步操作，删除节点 2第三步操作，删除节点4最后拓扑排序依次为 3 5，不再画图讲述。
数据结构之链表（算法之初）
FENGCHEN____的博客
05-27 493
int value;} ListNode;int value;} ListNode;int value;
浙江大学数据结构MOOC-课后习题-第九讲-排序1 排序
chan1ee的博客
05-27 301
题目汇总。
同济 数据结构 oj
09-30
同济数据结构OJ是同济大学开设的一个在线判题系统，用于帮助学生练习和巩固数据结构方面的知识。在OJ上，学生可以提交自己的代码，系统会自动判定其代码的正确性，并给出相应的评测结果和反馈。这个OJ包含了多种数据结构的经典问题和算法，如链表、栈、队列、二叉树、图等。学生可以通过在OJ上解题，提高自己的编程能力和对数据结构的理解。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值