zoukankan      html  css  js  c++  java
  • Lintcode: Rehashing

    The size of the hash table is not determinate at the very beginning. If the total size of keys is too large (e.g. size >= capacity / 10), we should double the size of the hash table and rehash every keys. Say you have a hash table looks like below:
    
    size=3, capacity=4
    [null, 21->9->null, 14->null, null]
    
    The hash function is:
    
    int hashcode(int key, int capacity) {
        return key % capacity;
    }
    
    here we have three numbers, 9, 14 and 21, where 21 and 9 share the same position as they all have the same hashcode 1 (21 % 4 = 9 % 4 = 1). We store them in the hash table by linked list.
    
    rehashing this hash table, double the capacity, you will get:
    
    size=3, capacity=8
    index:           0    1    2     3      4    5     6    7
    hash table: [null, 9, null, null, null, 21, 14, null]
    
    Given the original hash table, return the new hash table after rehashing .
    Note
    For negative integer in hash table, the position can be calculated as follow:
    
    In C++/Java, if you directly calculate -4 % 3 you will get -1. You can use function: a % b = (a % b + b) % b to make it is a non negative integer.
    
    In Python, you can directly use -1 % 3, you will get 2 automatically.
    
    Example
    Given [null, 21->9->null, 14->null, null], return [null, 9->null, null, null, null, 21->null, 14->null, null]

    这道题就是根据条件老老实实的做

     1 /**
     2  * Definition for ListNode
     3  * public class ListNode {
     4  *     int val;
     5  *     ListNode next;
     6  *     ListNode(int x) {
     7  *         val = x;
     8  *         next = null;
     9  *     }
    10  * }
    11  */
    12 public class Solution {
    13     /**
    14      * @param hashTable: A list of The first node of linked list
    15      * @return: A list of The first node of linked list which have twice size
    16      */    
    17     public ListNode[] rehashing(ListNode[] hashTable) {
    18         // write your code here
    19         int oldSize = hashTable.length;
    20         int newSize = oldSize * 2;
    21         if (hashTable==null || oldSize==0) return null;
    22         ListNode[] res = new ListNode[newSize];
    23         for (int i=0; i<oldSize; i++) {
    24             if (hashTable[i] != null) rehash(hashTable, res, i);
    25         }
    26         return res;
    27     }
    28     
    29     public void rehash(ListNode[] hashTable, ListNode[] res, int i) {
    30         int newSize = res.length;
    31         ListNode cur = hashTable[i];
    32         while (cur != null) {
    33             int val = cur.val;
    34             int newPos = val>=0? val%newSize : (val%newSize+newSize)%newSize;
    35             if (res[newPos] == null) res[newPos] = new ListNode(val);
    36             else {
    37                 ListNode temp = res[newPos];
    38                 while (temp.next != null) {
    39                     temp = temp.next;
    40                 }
    41                 temp.next = new ListNode(val);
    42             }
    43             cur = cur.next;
    44         }
    45     }
    46 };
  • 相关阅读:
    疫情环境下的网络学习笔记 python 5.8 数据库入门终章
    疫情环境下的网络学习笔记 python 5.7 navicat数据库,例题,sql注入
    疫情环境下的网络学习笔记 python 5.6 暂时看看
    疫情环境下的网络学习笔记 python 5.5 MYSql 表关系,外键
    疫情环境下的网络学习笔记 python 5.4 数据库基础
    疫情环境下的网络学习笔记 python 4.30 初识数据库
    疫情环境下的网络学习笔记 python 4.29 网络小项目
    XJOI 夏令营501-511测试11 游戏
    XJOI 夏令营501-511测试11 统计方案
    CF1197D Yet Another Subarray Problem
  • 原文地址:https://www.cnblogs.com/EdwardLiu/p/4386374.html
Copyright © 2011-2022 走看看