PAT-Hashing

题意：

1. MSize是给的哈希表最大容量，如果它不是素数，需要自己找一个大于MSize的最小素数。

2. Quadratic probing翻译为二次探查法，数值插入哈希表遇到冲突时，需要通过二次探查的方式找到新的可插入位置，如果找不到，返回“-”。

对于给定的Key，求它所在位置的过程如下:

第一次：position = （key+ d1*d1） % MSzie;  ( d1= 1)
第二次：position = （key+ d2*d2） % MSzie;  ( d2= 2)
第三次：position = （key+ d3*d3） % MSzie;  ( d3= 3)
第四次：position = （key+ d4*d4） % MSzie;  ( d4= 4)
…… …… ……
第  i 次： position = （key+ di*di）   % MSzie;  ( di = i )
其中 1<= di < MSize， 这里的MSize可能是修改后的值。

解答：

1、判断一个数是否为素数

2、获得所需的素数

3、本题有个技巧，先把第一个数加进去，这样格式就可以转化为（“  ”+a);不用担心末尾有空格的问题 

4、需要判断是否有重复，所以使用HashSet

具体的java代码：

import java.util.*;
public class Main{
       
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        int M=in.nextInt();
        int MSize=getNum(M);
        int N=in.nextInt();
        int[] a=new int[N];
        HashSet<Integer> set=new HashSet();
        for(int i=0;i<N;i++){
            a[i]=in.nextInt();
        }
        int p=a[0]%MSize;
        System.out.print(p);
        set.add(p);
        for(int i=1;i<N;i++){
            int left=a[i]%MSize;
            if(!set.contains(left)){
                System.out.print(" "+left);
                set.add(left);
            }
            else{
                int j=1;
                for( j=1;j<MSize;j++){
                    int t=(a[i]+j*j)%MSize;
                    if(!set.contains(t)){
                       System.out.print(" "+t);
                       set.add(t);
                        break;
                    }
                }
                if(j>=MSize){
                    System.out.print(" -");
                }
      
            }
               
        }
    }
   public static int getNum(int n) {
     
       for(int i=n;;i++)
            {
            if(isPrime(i))
                return i;
            
        }
    }
    public static boolean isPrime(int M){
      if(M<2)
          return false;
        boolean flag=true;
        for(int i=2;i<=Math.sqrt(M);i++){
            if(M%i==0) {
                flag=false;
                break;
            }
             
        }
        return flag;
    }
}