描述
哈希表容量的大小在一开始是不确定的。如果哈希表存储的元素太多(如超过容量的十分之一),我们应该将哈希表容量扩大一倍,并将所有的哈希值重新安排。假设你有如下一哈希表:
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;
}