StarMirror/CS-Notes
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

auto commit

Browse Source
This commit is contained in:
CyC2018 2018-06-07 10:40:56 +08:00
parent 5ddb1746c8
commit dff3e7ddc5
1 changed files with 364 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

538
notes/算法.md
View File

@ -28,10 +28,11 @@
* [排序算法的比较](#排序算法的比较) * [排序算法的比较](#排序算法的比较)
* [Java 的排序算法实现](#java-的排序算法实现) * [Java 的排序算法实现](#java-的排序算法实现)
* [六、查找](#六查找) * [六、查找](#六查找)
* [链表实现无序符号表](#链表实现无序符号表)
* [二分查找实现有序符号表](#二分查找实现有序符号表) * [二分查找实现有序符号表](#二分查找实现有序符号表)
* [二叉查找树](#二叉查找树) * [二叉查找树](#二叉查找树)
* [2-3 查找树](#2-3-查找树) * [2-3 查找树](#2-3-查找树)
* [红黑二叉查找树](#红黑二叉查找树) * [红黑树](#红黑树)
* [散列表](#散列表) * [散列表](#散列表)
* [应用](#应用) * [应用](#应用)
* [参考资料](#参考资料) * [参考资料](#参考资料)
@ -235,8 +236,8 @@ public interface MyStack<Item> extends Iterable<Item> {
```java ```java
public class ArrayStack<Item> implements MyStack<Item> { public class ArrayStack<Item> implements MyStack<Item> {
// 栈元素数组 // 栈元素数组，只能通过转型来创建泛型数组
private Item[] a = (Item[]) new Object[1]; // 只能通过转型来创建泛型数组 private Item[] a = (Item[]) new Object[1];
// 元素数量 // 元素数量
private int N = 0; private int N = 0;
@ -1127,12 +1128,119 @@ Java 主要排序方法为 java.util.Arrays.sort()，对于原始数据类型使
# 六、查找 # 六、查找
符号表是一种存储键值对的数据结构，主要支持两种操作：插入一个新的键值对、根据给定键得到值。 符号表（Symbol Table）是一种存储键值对的数据结构，可以支持快速查找操作。
符号表分为有序和无序两种，有序符号表主要指支持 min()、max() 等根据键的大小关系来实现的操作。 符号表分为有序和无序两种，有序符号表主要指支持 min()、max() 等根据键的大小关系来实现的操作。
有序符号表的键需要实现 Comparable 接口。 有序符号表的键需要实现 Comparable 接口。
```java
public interface UnorderedST<Key, Value> {
int size();
Value get(Key key);
void put(Key key, Value value);
void delete(Key key);
}
```
```java
public interface OrderedST<Key extends Comparable<Key>, Value> {
int size();
void put(Key key, Value value);
Value get(Key key);
Key min();
Key max();
int rank(Key key);
List<Key> keys(Key l, Key h);
}
```
## 链表实现无序符号表
```java
public class ListUnorderedST<Key, Value> implements UnorderedST<Key, Value> {
private Node first;
private class Node {
Key key;
Value value;
Node next;
Node(Key key, Value value, Node next) {
this.key = key;
this.value = value;
this.next = next;
}
}
@Override
public int size() {
int cnt = 0;
Node cur = first;
while (cur != null) {
cnt++;
cur = cur.next;
}
return cnt;
}
@Override
public void put(Key key, Value value) {
Node cur = first;
// 如果在链表中找到节点的键等于 key 就更新这个节点的值为 value
while (cur != null) {
if (cur.key.equals(key)) {
cur.value = value;
return;
}
cur = cur.next;
}
// 否则使用头插法插入一个新节点
first = new Node(key, value, first);
}
@Override
public void delete(Key key) {
if (first == null)
return;
if (first.key.equals(key))
first = first.next;
Node pre = first, cur = first.next;
while (cur != null) {
if (cur.key.equals(key)) {
pre.next = cur.next;
return;
}
pre = pre.next;
cur = cur.next;
}
}
@Override
public Value get(Key key) {
Node cur = first;
while (cur != null) {
if (cur.key.equals(key))
return cur.value;
cur = cur.next;
}
return null;
}
}
```
## 二分查找实现有序符号表 ## 二分查找实现有序符号表
使用一对平行数组，一个存储键一个存储值。 使用一对平行数组，一个存储键一个存储值。
@ -1142,58 +1250,83 @@ rank() 方法至关重要，当键在表中时，它能够知道该键的位置
复杂度：二分查找最多需要 logN+1 次比较，使用二分查找实现的符号表的查找操作所需要的时间最多是对数级别的。但是插入操作需要移动数组元素，是线性级别的。 复杂度：二分查找最多需要 logN+1 次比较，使用二分查找实现的符号表的查找操作所需要的时间最多是对数级别的。但是插入操作需要移动数组元素，是线性级别的。
```java ```java
public class BinarySearchST<Key extends Comparable<Key>, Value> { public class BinarySearchOrderedST<Key extends Comparable<Key>, Value> implements OrderedST<Key, Value> {
private Key[] keys; private Key[] keys;
private Value[] values; private Value[] values;
private int N; private int N = 0;
public BinarySearchST(int capacity) { public BinarySearchOrderedST(int capacity) {
keys = (Key[]) new Comparable[capacity]; keys = (Key[]) new Comparable[capacity];
values = (Value[]) new Object[capacity]; values = (Value[]) new Object[capacity];
} }
@Override
public int size() { public int size() {
return N; return N;
} }
public Value get(Key key) { @Override
int i = rank(key);
if (i < N && keys[i].compareTo(key) == 0) {
return values[i];
}
return null;
}
public int rank(Key key) { public int rank(Key key) {
int lo = 0, hi = N - 1; int l = 0, h = N - 1;
while (lo <= hi) { while (l <= h) {
int mid = lo + (hi - lo) / 2; int m = l + (h - l) / 2;
int cmp = key.compareTo(keys[mid]); int cmp = key.compareTo(keys[m]);
if (cmp == 0) return mid; if (cmp == 0)
else if (cmp < 0) hi = mid - 1; return m;
else lo = mid + 1; else if (cmp < 0)
h = m - 1;
else
l = m + 1;
} }
return lo; return l;
} }
@Override
public List<Key> keys(Key l, Key h) {
int index = rank(l);
List<Key> list = new ArrayList<>();
while (keys[index].compareTo(h) <= 0) {
list.add(keys[index]);
index++;
}
return list;
}
@Override
public void put(Key key, Value value) { public void put(Key key, Value value) {
int i = rank(key); int index = rank(key);
if (i < N && keys[i].compareTo(key) == 0) { // 如果找到已经存在的节点键位 key，就更新这个节点的值为 value
values[i] = value; if (index < N && keys[index].compareTo(key) == 0) {
values[index] = value;
return; return;
} }
for (int j = N; j > i; j--) { // 否则在数组中插入新的节点，需要先将插入位置之后的元素都向后移动一个位置
for (int j = N; j > index; j--) {
keys[j] = keys[j - 1]; keys[j] = keys[j - 1];
values[j] = values[j - 1]; values[j] = values[j - 1];
} }
keys[i] = key; keys[index] = key;
values[i] = value; values[index] = value;
N++; N++;
} }
public Key ceiling(Key key){ @Override
int i = rank(key); public Value get(Key key) {
return keys[i]; int index = rank(key);
if (index < N && keys[index].compareTo(key) == 0)
return values[index];
return null;
}
@Override
public Key min() {
return keys[0];
}
@Override
public Key max() {
return keys[N - 1];
} }
} }
``` ```
@ -1215,31 +1348,41 @@ BST 有一个重要性质，就是它的中序遍历结果递增排序。
基本数据结构： 基本数据结构：
```java ```java
public class BST<Key extends Comparable<Key>, Value> { public class BST<Key extends Comparable<Key>, Value> implements OrderedST<Key, Value> {
private Node root;
private class Node { protected Node root;
private Key key;
private Value val;
private Node left, right;
// 以该节点为根的子树中节点总数
private int N;
public Node(Key key, Value val, int N) { protected class Node {
Key key;
Value val;
Node left;
Node right;
// 以该节点为根的子树节点总数
int N;
// 红黑树中使用
boolean color;
Node(Key key, Value val, int N) {
this.key = key; this.key = key;
this.val = val; this.val = val;
this.N = N; this.N = N;
} }
} }
@Override
public int size() { public int size() {
return size(root); return size(root);
} }
private int size(Node x) { private int size(Node x) {
if (x == null) return 0; if (x == null)
return 0;
return x.N; return x.N;
} }
protected void recalculateSize(Node x) {
x.N = size(x.left) + size(x.right) + 1;
}
} }
``` ```
@ -1252,15 +1395,21 @@ public class BST<Key extends Comparable<Key>, Value> {
- 否则递归地在子树中查找：如果被查找的键较小就在左子树中查找，较大就在右子树中查找。 - 否则递归地在子树中查找：如果被查找的键较小就在左子树中查找，较大就在右子树中查找。
```java ```java
@Override
public Value get(Key key) { public Value get(Key key) {
return get(root, key); return get(root, key);
} }
private Value get(Node x, Key key) { private Value get(Node x, Key key) {
if (x == null) return null; if (x == null)
return null;
int cmp = key.compareTo(x.key); int cmp = key.compareTo(x.key);
if (cmp == 0) return x.val; if (cmp == 0)
else if (cmp < 0) return get(x.left, key); return x.val;
else return get(x.right, key); else if (cmp < 0)
return get(x.left, key);
else
return get(x.right, key);
} }
``` ```
@ -1271,16 +1420,22 @@ private Value get(Node x, Key key) {
<div align="center"> <img src="../pics//107a6a2b-f15b-4cad-bced-b7fb95258c9c.png" width="200"/> </div><br> <div align="center"> <img src="../pics//107a6a2b-f15b-4cad-bced-b7fb95258c9c.png" width="200"/> </div><br>
```java ```java
public void put(Key key, Value val) { @Override
root = put(root, key, val); public void put(Key key, Value value) {
root = put(root, key, value);
} }
private Node put(Node x, Key key, Value val) {
if (x == null) return new Node(key, val, 1); private Node put(Node x, Key key, Value value) {
if (x == null)
return new Node(key, value, 1);
int cmp = key.compareTo(x.key); int cmp = key.compareTo(x.key);
if (cmp == 0) x.val = val; if (cmp == 0)
else if (cmp < 0) x.left = put(x.left, key, val); x.val = value;
else x.right = put(x.right, key, val); else if (cmp < 0)
x.N = size(x.left) + size(x.right) + 1; x.left = put(x.left, key, value);
else
x.right = put(x.right, key, value);
recalculateSize(x);
return x; return x;
} }
``` ```
@ -1306,20 +1461,21 @@ floor(key)：小于等于键的最大键
```java ```java
public Key floor(Key key) { public Key floor(Key key) {
Node x = floor(root, key); Node x = floor(root, key);
if (x == null) return null; if (x == null)
return null;
return x.key; return x.key;
} }
private Node floor(Node x, Key key) { private Node floor(Node x, Key key) {
if (x == null) return null; if (x == null)
return null;
int cmp = key.compareTo(x.key); int cmp = key.compareTo(x.key);
if (cmp == 0) return x; if (cmp == 0)
if (cmp < 0) return floor(x.left, key);
Node t = floor(x.right, key);
if (t != null) {
return t;
} else {
return x; return x;
} if (cmp < 0)
return floor(x.left, key);
Node t = floor(x.right, key);
return t != null ? t : x;
} }
``` ```
@ -1332,24 +1488,37 @@ rank(key) 返回 key 的排名。
- 如果大于，递归计算在右子树中的排名，并加上左子树的节点数，再加上 1（根节点）。 - 如果大于，递归计算在右子树中的排名，并加上左子树的节点数，再加上 1（根节点）。
```java ```java
@Override
public int rank(Key key) { public int rank(Key key) {
return rank(key, root); return rank(key, root);
} }
private int rank(Key key, Node x) { private int rank(Key key, Node x) {
if (x == null) return 0; if (x == null)
return 0;
int cmp = key.compareTo(x.key); int cmp = key.compareTo(x.key);
if (cmp == 0) return size(x.left); if (cmp == 0)
else if (cmp < 0) return rank(key, x.left); return size(x.left);
else return 1 + size(x.left) + rank(key, x.right); else if (cmp < 0)
return rank(key, x.left);
else
return 1 + size(x.left) + rank(key, x.right);
} }
``` ```
### 6. min() ### 6. min()
```java ```java
@Override
public Key min() {
return min(root).key;
}
private Node min(Node x) { private Node min(Node x) {
if (x == null) return null; if (x == null)
if (x.left == null) return x; return null;
if (x.left == null)
return x;
return min(x.left); return min(x.left);
} }
``` ```
@ -1364,10 +1533,12 @@ private Node min(Node x) {
public void deleteMin() { public void deleteMin() {
root = deleteMin(root); root = deleteMin(root);
} }
public Node deleteMin(Node x) { public Node deleteMin(Node x) {
if (x.left == null) return x.right; if (x.left == null)
return x.right;
x.left = deleteMin(x.left); x.left = deleteMin(x.left);
x.N = size(x.left) + size(x.right) + 1; recalculateSize(x);
return x; return x;
} }
``` ```
@ -1379,25 +1550,29 @@ public Node deleteMin(Node x) {
<div align="center"> <img src="../pics//fa568fac-ac58-48dd-a9bb-23b3065bf2dc.png" width="400"/> </div><br> <div align="center"> <img src="../pics//fa568fac-ac58-48dd-a9bb-23b3065bf2dc.png" width="400"/> </div><br>
```java ```java
public void delete(Key key) { public void delete(Key key) {
root = delete(root, key); root = delete(root, key);
} }
private Node delete(Node x, Key key) { private Node delete(Node x, Key key) {
if (x == null) return null; if (x == null)
return null;
int cmp = key.compareTo(x.key); int cmp = key.compareTo(x.key);
if (cmp < 0) x.left = delete(x.left, key); if (cmp < 0)
else if (cmp > 0) x.right = delete(x.right, key); x.left = delete(x.left, key);
else if (cmp > 0)
x.right = delete(x.right, key);
else { else {
if (x.right == null) return x.left; if (x.right == null)
if (x.left == null) return x.right; return x.left;
if (x.left == null)
return x.right;
Node t = x; Node t = x;
x = min(t.right); x = min(t.right);
x.right = deleteMin(t.right); x.right = deleteMin(t.right);
x.left = t.left; x.left = t.left;
} }
x.N = size(x.left) + size(x.right) + 1; recalculateSize(x);
return x; return x;
} }
``` ```
@ -1407,18 +1582,24 @@ private Node delete(Node x, Key key) {
利用二叉查找树中序遍历的结果为递增的特点。 利用二叉查找树中序遍历的结果为递增的特点。
```java ```java
public Iterable<Key> keys(Key lo, Key hi) { @Override
Queue<Key> queue = new LinkedList<>(); public List<Key> keys(Key l, Key h) {
keys(root, queue, lo, hi); return keys(root, l, h);
return queue;
} }
private void keys(Node x, Queue<Key> queue, Key lo, Key hi) {
if (x == null) return; private List<Key> keys(Node x, Key l, Key h) {
int cmpLo = lo.compareTo(x.key); List<Key> list = new ArrayList<>();
int cmpHi = hi.compareTo(x.key); if (x == null)
if (cmpLo < 0) keys(x.left, queue, lo, hi); return list;
if (cmpLo <= 0 && cmpHi >= 0) queue.add(x.key); int cmpL = l.compareTo(x.key);
if (cmpHi > 0) keys(x.right, queue, lo, hi); int cmpH = h.compareTo(x.key);
if (cmpL < 0)
list.addAll(keys(x.left, l, h));
if (cmpL <= 0 && cmpH >= 0)
list.add(x.key);
if (cmpH > 0)
list.addAll(keys(x.right, l, h));
return list;
} }
``` ```
@ -1436,13 +1617,13 @@ private void keys(Node x, Queue<Key> queue, Key lo, Key hi) {
插入操作和 BST 的插入操作有很大区别，BST 的插入操作是先进行一次未命中的查找，然后再将节点插入到对应的空链接上。但是 2-3 查找树如果也这么做的话，那么就会破坏了平衡性。它是将新节点插入到叶子节点上。 插入操作和 BST 的插入操作有很大区别，BST 的插入操作是先进行一次未命中的查找，然后再将节点插入到对应的空链接上。但是 2-3 查找树如果也这么做的话，那么就会破坏了平衡性。它是将新节点插入到叶子节点上。
根据叶子节点的类型不同，有不同的处理方式。 根据叶子节点的类型不同，有不同的处理方式：
插入到 2- 节点上，那么直接将新节点和原来的节点组成 3- 节点即可。 - 如果插入到 2- 节点上，那么直接将新节点和原来的节点组成 3- 节点即可。
<div align="center"> <img src="../pics//7f38a583-2f2e-4738-97af-510e6fb403a7.png" width="400"/> </div><br> <div align="center"> <img src="../pics//7f38a583-2f2e-4738-97af-510e6fb403a7.png" width="400"/> </div><br>
如果是插入到 3- 节点上，就会产生一个临时 4- 节点时，需要将 4- 节点分裂成 3 个 2- 节点，并将中间的 2- 节点移到上层节点中。如果上移操作继续产生临时 4- 节点则一直进行分裂上移，直到不存在临时 4- 节点。 - 如果是插入到 3- 节点上，就会产生一个临时 4- 节点时，需要将 4- 节点分裂成 3 个 2- 节点，并将中间的 2- 节点移到上层节点中。如果上移操作继续产生临时 4- 节点则一直进行分裂上移，直到不存在临时 4- 节点。
<div align="center"> <img src="../pics//ef280699-da36-4b38-9735-9b048a3c7fe0.png" width="500"/> </div><br> <div align="center"> <img src="../pics//ef280699-da36-4b38-9735-9b048a3c7fe0.png" width="500"/> </div><br>
@ -1452,7 +1633,7 @@ private void keys(Node x, Queue<Key> queue, Key lo, Key hi) {
2-3 查找树的查找和插入操作复杂度和插入顺序无关，在最坏的情况下查找和插入操作访问的节点必然不超过 logN 个，含有 10 亿个节点的 2-3 查找树最多只需要访问 30 个节点就能进行任意的查找和插入操作。 2-3 查找树的查找和插入操作复杂度和插入顺序无关，在最坏的情况下查找和插入操作访问的节点必然不超过 logN 个，含有 10 亿个节点的 2-3 查找树最多只需要访问 30 个节点就能进行任意的查找和插入操作。
## 红黑二叉查找树 ## 红黑树
2-3 查找树需要用到 2- 节点和 3- 节点，红黑树使用红链接来实现 3- 节点。指向一个节点的链接颜色如果为红色，那么这个节点和上层节点表示的是一个 3- 节点，而黑色则是普通链接。 2-3 查找树需要用到 2- 节点和 3- 节点，红黑树使用红链接来实现 3- 节点。指向一个节点的链接颜色如果为红色，那么这个节点和上层节点表示的是一个 3- 节点，而黑色则是普通链接。
@ -1460,36 +1641,21 @@ private void keys(Node x, Queue<Key> queue, Key lo, Key hi) {
红黑树具有以下性质： 红黑树具有以下性质：
1. 红链接都为左链接； - 红链接都为左链接；
2. 完美黑色平衡，即任意空链接到根节点的路径上的黑链接数量相同。 - 完美黑色平衡，即任意空链接到根节点的路径上的黑链接数量相同。
画红黑树时可以将红链接画平。 画红黑树时可以将红链接画平。
<div align="center"> <img src="../pics//3086c248-b552-499e-b101-9cffe5c2773e.png" width="300"/> </div><br> <div align="center"> <img src="../pics//3086c248-b552-499e-b101-9cffe5c2773e.png" width="300"/> </div><br>
```java ```java
public class RedBlackBST<Key extends Comparable<Key>, Value> { public class RedBlackBST<Key extends Comparable<Key>, Value> extends BST<Key, Value> {
private Node root;
private static final boolean RED = true; private static final boolean RED = true;
private static final boolean BLACK = false; private static final boolean BLACK = false;
private class Node {
Key key;
Value val;
Node left, right;
int N;
boolean color;
Node(Key key, Value val, int n, boolean color) {
this.key = key;
this.val = val;
N = n;
this.color = color;
}
}
private boolean isRed(Node x) { private boolean isRed(Node x) {
if (x == null) return false; if (x == null)
return false;
return x.color == RED; return x.color == RED;
} }
} }
@ -1509,7 +1675,7 @@ public Node rotateLeft(Node h) {
x.color = h.color; x.color = h.color;
h.color = RED; h.color = RED;
x.N = h.N; x.N = h.N;
h.N = 1 + size(h.left) + size(h.right); recalculateSize(h);
return x; return x;
} }
``` ```
@ -1527,7 +1693,7 @@ public Node rotateRight(Node h) {
x.color = h.color; x.color = h.color;
h.color = RED; h.color = RED;
x.N = h.N; x.N = h.N;
h.N = 1 + size(h.left) + size(h.right); recalculateSize(h);
return x; return x;
} }
``` ```
@ -1539,7 +1705,7 @@ public Node rotateRight(Node h) {
<div align="center"> <img src="../pics//af4639f9-af54-4400-aaf5-4e261d96ace7.png" width="300"/> </div><br> <div align="center"> <img src="../pics//af4639f9-af54-4400-aaf5-4e261d96ace7.png" width="300"/> </div><br>
```java ```java
void flipColors(Node h){ void flipColors(Node h) {
h.color = RED; h.color = RED;
h.left.color = BLACK; h.left.color = BLACK;
h.right.color = BLACK; h.right.color = BLACK;
@ -1557,23 +1723,34 @@ void flipColors(Node h){
<div align="center"> <img src="../pics//08427d38-8df1-49a1-8990-e0ce5ee36ca2.png" width="400"/> </div><br> <div align="center"> <img src="../pics//08427d38-8df1-49a1-8990-e0ce5ee36ca2.png" width="400"/> </div><br>
```java ```java
public void put(Key key, Value val) { @Override
root = put(root, key, val); public void put(Key key, Value value) {
root = put(root, key, value);
root.color = BLACK; root.color = BLACK;
} }
private Node put(Node x, Key key, Value val) { private Node put(Node x, Key key, Value value) {
if (x == null) return new Node(key, val, 1, RED); if (x == null) {
Node node = new Node(key, value, 1);
node.color = RED;
return node;
}
int cmp = key.compareTo(x.key); int cmp = key.compareTo(x.key);
if (cmp == 0) x.val = val; if (cmp == 0)
else if (cmp < 0) x.left = put(x.left, key, val); x.val = value;
else x.right = put(x.right, key, val); else if (cmp < 0)
x.left = put(x.left, key, value);
else
x.right = put(x.right, key, value);
if (isRed(x.right) && !isRed(x.left)) x = rotateLeft(x); if (isRed(x.right) && !isRed(x.left))
if (isRed(x.left) && isRed(x.left.left)) x = rotateRight(x); x = rotateLeft(x);
if (isRed(x.left) && isRed(x.right)) flipColors(x); if (isRed(x.left) && isRed(x.left.left))
x = rotateRight(x);
if (isRed(x.left) && isRed(x.right))
flipColors(x);
x.N = size(x.left) + size(x.right) + 1; recalculateSize(x);
return x; return x;
} }
``` ```
@ -1598,13 +1775,13 @@ private Node put(Node x, Key key, Value val) {
对于一个大小为 M 的散列表，散列函数能够把任意键转换为 [0, M-1] 内的正整数，该正整数即为 hash 值。 对于一个大小为 M 的散列表，散列函数能够把任意键转换为 [0, M-1] 内的正整数，该正整数即为 hash 值。
散列表有冲突的存在，也就是两个不同的键可能有相同的 hash 值。 散列表存在冲突，也就是两个不同的键可能有相同的 hash 值。
散列函数应该满足以下三个条件： 散列函数应该满足以下三个条件：
1. 一致性：相等的键应当有相等的 hash 值，两个键相等表示调用 equals() 返回的值相等。 - 一致性：相等的键应当有相等的 hash 值，两个键相等表示调用 equals() 返回的值相等。
2. 高效性：计算应当简便，有必要的话可以把 hash 值缓存起来，在调用 hash 函数时直接返回。 - 高效性：计算应当简便，有必要的话可以把 hash 值缓存起来，在调用 hash 函数时直接返回。
3. 均匀性：所有键的 hash 值应当均匀地分布到 [0, M-1] 之间，这个条件至关重要，直接影响到散列表的性能。 - 均匀性：所有键的 hash 值应当均匀地分布到 [0, M-1] 之间，这个条件至关重要，直接影响到散列表的性能。
除留余数法可以将整数散列到 [0, M-1] 之间，例如一个正整数 k，计算 k%M 既可得到一个 [0, M-1] 之间的 hash 值。注意 M 必须是一个素数，否则无法利用键包含的所有信息。例如 M 为 10<sup>k</sup>，那么只能利用键的后 k 位。 除留余数法可以将整数散列到 [0, M-1] 之间，例如一个正整数 k，计算 k%M 既可得到一个 [0, M-1] 之间的 hash 值。注意 M 必须是一个素数，否则无法利用键包含的所有信息。例如 M 为 10<sup>k</sup>，那么只能利用键的后 k 位。
@ -1616,7 +1793,7 @@ private Node put(Node x, Key key, Value val) {
```java ```java
int hash = 0; int hash = 0;
for(int i = 0; i < s.length(); i++) for (int i = 0; i < s.length(); i++)
hash = (R * hash + s.charAt(i)) % M; hash = (R * hash + s.charAt(i)) % M;
``` ```
@ -1637,16 +1814,23 @@ int hash = (x.hashCode() & 0x7fffffff) % M;
使用 Java 自带的 HashMap 等自带的哈希表实现时，只需要去实现 Key 类型的 hashCode() 函数即可。Java 规定 hashCode() 能够将键均匀分布于所有的 32 位整数，Java 中的 String、Integer 等对象的 hashCode() 都能实现这一点。以下展示了自定义类型如何实现 hashCode()。 使用 Java 自带的 HashMap 等自带的哈希表实现时，只需要去实现 Key 类型的 hashCode() 函数即可。Java 规定 hashCode() 能够将键均匀分布于所有的 32 位整数，Java 中的 String、Integer 等对象的 hashCode() 都能实现这一点。以下展示了自定义类型如何实现 hashCode()。
```java ```java
public class Transaction{ public class Transaction {
private final String who; private final String who;
private final Date when; private final Date when;
private final double amount; private final double amount;
public int hashCode(){ public Transaction(String who, Date when, double amount) {
this.who = who;
this.when = when;
this.amount = amount;
}
public int hashCode() {
int hash = 17; int hash = 17;
hash = 31 * hash + who.hashCode(); int R = 31;
hash = 31 * hash + when.hashCode(); hash = R * hash + who.hashCode();
hash = 31 * hash + ((Double) amount).hashCode(); hash = R * hash + when.hashCode();
hash = R * hash + ((Double) amount).hashCode();
return hash; return hash;
} }
} }
@ -1667,11 +1851,11 @@ public class Transaction{
<div align="center"> <img src="../pics//dbb8516d-37ba-4e2c-b26b-eefd7de21b45.png" width="400"/> </div><br> <div align="center"> <img src="../pics//dbb8516d-37ba-4e2c-b26b-eefd7de21b45.png" width="400"/> </div><br>
```java ```java
public class LinearProbingHashST<Key, Value> { public class LinearProbingHashST<Key, Value> implements UnorderedST<Key, Value> {
private int N; private int N = 0;
private int M = 16; private int M = 16;
private Key[] keys; private Key[] keys;
private Value[] vals; private Value[] values;
public LinearProbingHashST() { public LinearProbingHashST() {
init(); init();
@ -1684,7 +1868,7 @@ public class LinearProbingHashST<Key, Value> {
private void init() { private void init() {
keys = (Key[]) new Object[M]; keys = (Key[]) new Object[M];
vals = (Value[]) new Object[M]; values = (Value[]) new Object[M];
} }
private int hash(Key key) { private int hash(Key key) {
@ -1697,11 +1881,10 @@ public class LinearProbingHashST<Key, Value> {
```java ```java
public Value get(Key key) { public Value get(Key key) {
for (int i = hash(key); keys[i] != null; i = (i + 1) % M) { for (int i = hash(key); keys[i] != null; i = (i + 1) % M)
if (keys[i].equals(key)) { if (keys[i].equals(key))
return vals[i]; return values[i];
}
}
return null; return null;
} }
``` ```
@ -1709,18 +1892,22 @@ public Value get(Key key) {
**（二）插入** **（二）插入**
```java ```java
public void put(Key key, Value val) { public void put(Key key, Value value) {
resize();
putInternal(key, value);
}
private void putInternal(Key key, Value value) {
int i; int i;
for (i = hash(key); keys[i] != null; i = (i + 1) % M) { for (i = hash(key); keys[i] != null; i = (i + 1) % M)
if (keys[i].equals(key)) { if (keys[i].equals(key)) {
vals[i] = val; values[i] = value;
return; return;
} }
}
keys[i] = key; keys[i] = key;
vals[i] = val; values[i] = value;
N++; N++;
resize();
} }
``` ```
@ -1730,21 +1917,26 @@ public void put(Key key, Value val) {
```java ```java
public void delete(Key key) { public void delete(Key key) {
if (!contains(key)) return;
int i = hash(key); int i = hash(key);
while (!key.equals(keys[i])) { while (keys[i] != null && !key.equals(keys[i]))
i = (i + 1) % M; i = (i + 1) % M;
}
// 不存在，直接返回
if (keys[i] == null)
return;
keys[i] = null; keys[i] = null;
vals[i] = null; values[i] = null;
// 将之后相连的键值对重新插入
i = (i + 1) % M; i = (i + 1) % M;
while (keys[i] != null) { while (keys[i] != null) {
Key keyToRedo = keys[i]; Key keyToRedo = keys[i];
Value valToRedo = vals[i]; Value valToRedo = values[i];
keys[i] = null; keys[i] = null;
vals[i] = null; values[i] = null;
N--; N--;
put(keyToRedo, valToRedo); putInternal(keyToRedo, valToRedo);
i = (i + 1) % M; i = (i + 1) % M;
} }
N--; N--;
@ -1764,19 +1956,20 @@ public void delete(Key key) {
```java ```java
private void resize() { private void resize() {
if (N >= M / 2) resize(2 * M); if (N >= M / 2)
else if (N <= M / 8) resize(M / 2); resize(2 * M);
else if (N <= M / 8)
resize(M / 2);
} }
private void resize(int cap) { private void resize(int cap) {
LinearProbingHashST<Key, Value> t = new LinearProbingHashST<>(cap); LinearProbingHashST<Key, Value> t = new LinearProbingHashST<Key, Value>(cap);
for (int i = 0; i < M; i++) { for (int i = 0; i < M; i++)
if (keys[i] != null) { if (keys[i] != null)
t.put(keys[i], vals[i]); t.putInternal(keys[i], values[i]);
}
}
keys = t.keys; keys = t.keys;
vals = t.vals; values = t.values;
M = t.M; M = t.M;
} }
``` ```
@ -1814,11 +2007,9 @@ public class SparseVector {
public SparseVector(double[] vector) { public SparseVector(double[] vector) {
hashMap = new HashMap<>(); hashMap = new HashMap<>();
for (int i = 0; i < vector.length; i++) { for (int i = 0; i < vector.length; i++)
if (vector[i] != 0) { if (vector[i] != 0)
hashMap.put(i, vector[i]); hashMap.put(i, vector[i]);
}
}
} }
public double get(int i) { public double get(int i) {
@ -1827,9 +2018,8 @@ public class SparseVector {
public double dot(SparseVector other) { public double dot(SparseVector other) {
double sum = 0; double sum = 0;
for (int i : hashMap.keySet()) { for (int i : hashMap.keySet())
sum += this.get(i) * other.get(i); sum += this.get(i) * other.get(i);
}
return sum; return sum;
} }
} }