LintCode : 重哈希

描述

哈希表容量的大小在一开始是不确定的。如果哈希表存储的元素太多（如超过容量的十分之一），我们应该将哈希表容量扩大一倍，并将所有的哈希值重新安排。假设你有如下一哈希表：

size=3, capacity=4

[null, 21, 14, null]
       ↓    ↓
       9   null
       ↓
      null

哈希函数为：

int hashcode(int key, int capacity) {
    return key % capacity;
}

这里有三个数字9，14，21，其中21和9共享同一个位置因为它们有相同的哈希值1(21 % 4 = 9 % 4 = 1)。我们将它们存储在同一个链表中。

重建哈希表，将容量扩大一倍，我们将会得到：

size=3, capacity=8

index:   0    1    2    3     4    5    6   7
hash : [null, 9, null, null, null, 21, 14, null]

给定一个哈希表，返回重哈希后的哈希表。

哈希表中负整数的下标位置可以通过下列方式计算：

• C++/Java：如果你直接计算-4 % 3，你会得到-1，你可以应用函数：a % b = (a % b + b) % b得到一个非负整数。
• Python：你可以直接用-1 % 3，你可以自动得到2。

您在真实的面试中是否遇到过这个题？   是

样例

给出 [null, 21->9->null, 14->null, null]

返回 [null, 9->null, null, null, null, 21->null, 14->null, null]

思路

直接new出一个长度两倍的数组，然后将原数组中的所有元素重hash就可以了。

Lintcode中每个链表插在头部居然不通过，只能在尾部插入，。。

先放通过的代码：

public ListNode[] rehashing(ListNode[] hashTable) {
        // write your code here
        if (hashTable.length <= 0) {
            return hashTable;
        }
        int newcapacity = 2 * hashTable.length;
        ListNode[] newTable = new ListNode[newcapacity];
        for (int i = 0; i < hashTable.length; i++) {
            while (hashTable[i] != null) {
                int newindex
                 = (hashTable[i].val % newcapacity + newcapacity) % newcapacity;
                if (newTable[newindex] == null) {
                    newTable[newindex] = new ListNode(hashTable[i].val);
                   // newTable[newindex].next = null;
                } else {
                    ListNode dummy = newTable[newindex];
                    while (dummy.next != null) {
                        dummy = dummy.next;
                    }
                    dummy.next = new ListNode(hashTable[i].val);
                }
                hashTable[i] = hashTable[i].next;
            }
        }
        return newTable;
    }

再放之前写的：

public ListNode[] rehashing(ListNode[] hashTable) {
        // write your code here
        int len = 2 * hashTable.length;
        ListNode[] newTable = new ListNode[len];
        for (ListNode temp : hashTable) {
            if (temp == null) {
                continue;
            } else {
                while (temp != null) {
                    int location = (temp.val % len+len)%len;
                    ListNode node = new ListNode(temp.val);
                    if (newTable[location] == null) {
                        newTable[location] = node;
                    } else {
                        if (newTable[location].next != null) {
                            node.next = newTable[location].next;
                        }
                        newTable[location].next = node;
                    }
                    temp = temp.next;
                }
            }
        }
        return newTable;
    }