cs61b homework6

终于能实现HashTable了！！之前看书一直没搞懂compression那的质数是什么意思，看lecture才明白，对prime求余数可以避免keys的hashcode均可被某一数整除从而造成collision过多的情况（这个概念好难形容啊感觉，具体参见lecture哈），compression算法：（（a*hashcode+b）%p)%N，其中p为略大于N的质数。不过a和b我不知道有啥要求没，我是随便取的。

part1：

注意数组内的list要初始化，makeEmpty（）后应重新初始化。

HashTableChains代码：

import java.text.DecimalFormat;
import java.util.Random;

import list.DList;
import list.InvalidNodeException;
import list.List;
import list.ListNode;


public class HashTableChained implements Dictionary {
    private List[]listarray;
    private int size;

  private boolean isPrime(int n){
      if(n>2&&n%2==0)
          return false;
      for(int i=3;i*i<=n;i+=2){
          if(n%i==0)
              return false;
      }
      return true;
  }

  public HashTableChained(int sizeEstimate) {
    while(!isPrime(sizeEstimate)){
        sizeEstimate++;
    }
    listarray=new List[sizeEstimate];
    for(int i=0;i<sizeEstimate;i++)
        listarray[i]=new DList();
  }

 
  public HashTableChained() {
    listarray=new List[127];
    for(int i=0;i<127;i++)
        listarray[i]=new DList();
  }



  int compFunction(int code) {
    Random rand=new Random();
    int a=7;
    int b=13;
    int p=listarray.length+1;
    while(!isPrime(p))
        p++;
    int comp=((code*a+b)%p)%(listarray.length-1);
    return comp;
    
  }


  public int size() {
    // Replace the following line with your solution.
    return size;
  }

  /** 
   *  Tests if the dictionary is empty.
   *
   *  @return true if the dictionary has no entries; false otherwise.
   **/

  public boolean isEmpty() {
    // Replace the following line with your solution.
    return(size==0);
  }


  public Entry insert(Object key, Object value) {
    int comp=compFunction(key.hashCode());
    Entry entry=new Entry();
    entry.key=key;
    entry.value=value;
    listarray[comp].insertBack(entry);
    size++;
    return entry;
  }

  public Entry find(Object key) {
    int comp=compFunction(key.hashCode());
    if(listarray[comp]==null||listarray[comp].isEmpty())
        return null;
    else if(listarray[comp].length()==1)
        try {
            return ((Entry)(listarray[comp].front().item()));
        } catch (InvalidNodeException e) {
            e.printStackTrace();
            return null;
        }
    else{
        try{
        Random rand=new Random();
        int r=rand.nextInt(listarray[comp].length());
        ListNode node=listarray[comp].front();
        for(int i=0;i<r-1;i++)
            node=node.next();
        return (Entry)(node.item());}
        catch(InvalidNodeException e){
            e.printStackTrace();
            return null;
        }
    }
}


  public Entry remove(Object key) {
      int comp=compFunction(key.hashCode());
        if(listarray[comp]==null||listarray[comp].isEmpty())
            return null;
        else if(listarray[comp].length()==1){
            try {
                Entry entry=new Entry();
                entry.key=((Entry)(listarray[comp].front().item())).key;
                entry.value=((Entry)(listarray[comp].front().item())).value;
                listarray[comp].front().remove();
                size--;
                return entry;
            } catch (InvalidNodeException e) {
                e.printStackTrace();
                return null;
            }   }
        else{
            try{
            Random rand=new Random();
            int r=rand.nextInt(listarray[comp].length());
            ListNode node=listarray[comp].front();
            for(int i=0;i<r-1;i++)
                node=node.next();
            Entry entry=new Entry();
            entry.key=((Entry)(node.item())).key;
            entry.value=((Entry)(node.item())).value;
            node.remove();
            size--;
            return entry;
            }
            catch(InvalidNodeException e){
                e.printStackTrace();
                return null;
            }
        }
  }

  public void makeEmpty() {
      listarray=new List[listarray.length];
      for(int i=0;i<listarray.length;i++)
          listarray[i]=new DList();
      size=0;
    // Your solution here.
  }
  public void histograph(){
      double collisions=this.size-listarray.length+listarray.length*Math.pow((1-(double)(1.0/(double)listarray.length)),(double) size);
      DecimalFormat df=new DecimalFormat("#.00");
      System.out.println("The expected collisions are: "+df.format(collisions));
      int count=1;
      int realCollisions=0;
      for(int i=0;i<listarray.length;i++){
          System.out.print("["+listarray[i].length()+"]");
          if(listarray[i].length()>1)
              realCollisions+=listarray[i].length()-1;
          if(count%10==0){
              System.out.println();
              count=0;
          }
          count++;
      }
      System.out.println();
      System.out.println("The real collisions are: "+realCollisions);
  }

}

part2:主要是hashcode的算法，按任务上建议的是将每一格点的值化成3进制数的一位，最后内存会存在溢出，所以要强制转换为int。

代码：

      public int hashCode() {
          int b=0;
          for(int i=0;i<DIMENSION;i++){
              for(int j=0;j<DIMENSION;j++){
                  int k=8*i+j;
                  int g=grid[i][j];
                  b+=(int)(g*(int)(3^k));
              }
          }
          return b;
      }

运行结果：每个格子代表该位置存的Entry的个数，collisions和预估的结果还蛮一致。

ps：lab8让设计project2的interface，lab9让证明时间复杂度，都不是编程的task就不打卡了，准备直接开始project2啦。