1145 Hashing - Average Search Time (25分)

1145 Hashing - Average Search Time (25分)
The task of this problem is simple: insert a sequence of distinct positive integers into a hash table first. Then try to find another sequence of integer keys from the table and output the average search time (the number of comparisons made to find whether or not the key is in the table). The hash function is defined to be H(key)=key%TSize where TSize is the maximum size of the hash table. Quadratic probing (with positive increments only) is used to solve the collisions.

Note that the table size is better to be prime. If the maximum size given by the user is not prime, you must re-define the table size to be the smallest prime number which is larger than the size given by the user.

Input Specification:
Each input file contains one test case. For each case, the first line contains 3 positive numbers: MSize, N, and M, which are the user-defined table size, the number of input numbers, and the number of keys to be found, respectively. All the three numbers are no more than 10 ​4
​​ . Then N distinct positive integers are given in the next line, followed by M positive integer keys in the next line. All the numbers in a line are separated by a space and are no more than 10 ​5

Output Specification:
For each test case, in case it is impossible to insert some number, print in a line X cannot be inserted. where X is the input number. Finally print in a line the average search time for all the M keys, accurate up to 1 decimal place.

Sample Input:

4 5 4
10 6 4 15 11
11 4 15 2

Sample Output:

15 cannot be inserted.
2.8

分析:
题目考察的是二次方探测方法的hash表存储和查询，这题有点小坑的~
先上代码再说下坑：

#include<iostream>
#include<vector>
using namespace std;
int Msize, n, m;
vector<int> hashtable;
bool isPrime(int x){
    if(x<2)
        return 0;
    for (int i = 2; i * i <= x;i++){
        if(x%i==0)
            return 0;
    }
    return 1;
}
//插入的策略是有空位就插入，否则继续二次方探测空位
void insert(int x){
    for (int i = 0; i < Msize;i++){
        int key = (x + i * i) % Msize;
        if(hashtable[key]==0){
            hashtable[key] = x;
            return;
        }
    }
    printf("%d cannot be inserted.\n",x);
}
//搜索的策略是确定搜索成功或搜索失败则停止(包括找到了和搜索到了一个空位--也就是没找到)，不确定的话则继续搜索
void search(int x,int &time){
    for (int i = 0; i <= Msize;i++){
        int key = (x + i * i) % Msize;
        time = time + 1;
        if(hashtable[key]==0 || hashtable[key] ==x)
            return;
    }
}
int main(){
    cin >> Msize >> n >> m;
    for (;!isPrime(Msize);Msize++);
    hashtable.resize(Msize,0);
    while(n--){
        int temp;
        cin >> temp;
        insert(temp);
    }
    int time = 0;
    for (int i = 0; i < m;i++){
        int temp;
        cin >> temp;
        search(temp,time);
    }
    printf("%.1f", 1.0*time/m);
    return 0;
}

坑:

首先：
1.插入的策略是有空位就插入，否则继续二次方探测空位；
2.搜索的策略是确定搜索成功或搜索失败则停止(包括找到了和搜索到了一个空位–也就是没找到)，不确定的话则继续搜索
注意点:
1.搜索中止的条件有2个：一是搜索到正确的数，二是搜索到了一个空位（这种情况容易被忽视！如果搜索到空位了，从插入这个数据的角度来说，这个空位一定是可以插入该数据的，所以能够证明这个数不存在hash表中，搜索中止）
2.有一个地方有个问题：

void search(int x,int &time){
    for (int i = 0; i <= Msize;i++){

其中的i竟然要同时取0和Msize才能算出答案来，但是，按照实际来想

key = (x + 0 * 0) % Msize;

和

key = (x + Msize * Msize) % Msize;

这两种情况有何区别呢？
我个人认位没区别，但是这题确实是要这么算才能出答案= =.