xmengnet/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2024-12-26 11:56:30 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

build

Browse source
This commit is contained in:
krahets 2023-06-26 23:13:42 +08:00
parent c0b24f1d8f
commit ce6ce9b444
5 changed files with 291 additions and 109 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
chapter_array_and_linkedlist/list.md
View file

@ -950,7 +950,7 @@ comments: true
// 元素数量超出容量时，触发扩容机制
if (size() == capacity())
extendCapacity();
// 索引 i 以及之后的元素都向后移动一位
// 将索引 index 以及之后的元素都向后移动一位
for (int j = size() - 1; j >= index; j--) {
nums[j + 1] = nums[j];
}
@ -1050,7 +1050,7 @@ comments: true
# 元素数量超出容量时，触发扩容机制
if self.__size == self.capacity():
self.extend_capacity()
# 索引 i 以及之后的元素都向后移动一位
# 将索引 index 以及之后的元素都向后移动一位
for j in range(self.__size - 1, index - 1, -1):
self.__nums[j + 1] = self.__nums[j]
self.__nums[index] = num
@ -1150,7 +1150,7 @@ comments: true
if l.numsSize == l.numsCapacity {
l.extendCapacity()
}
// 索引 i 以及之后的元素都向后移动一位
// 将索引 index 以及之后的元素都向后移动一位
for j := l.numsSize - 1; j >= index; j-- {
l.nums[j+1] = l.nums[j]
}
@ -1776,7 +1776,7 @@ comments: true
if (index < 0 or index >= self.size()) @panic("索引越界");
// 元素数量超出容量时，触发扩容机制
if (self.size() == self.capacity()) try self.extendCapacity();
// 索引 i 以及之后的元素都向后移动一位
// 将索引 index 以及之后的元素都向后移动一位
var j = self.size() - 1;
while (j >= index) : (j -= 1) {
self.nums[j + 1] = self.nums[j];

62
chapter_hashing/hash_algorithm.md
View file

@ -265,13 +265,45 @@ index = hash(key) % capacity
=== "C#"
```csharp title="simple_hash.cs"
[class]{simple_hash}-[func]{addHash}
/* 加法哈希 */
int addHash(string key) {
long hash = 0;
const int MODULUS = 1000000007;
foreach (char c in key) {
hash = (hash + c) % MODULUS;
}
return (int)hash;
}
[class]{simple_hash}-[func]{mulHash}
/* 乘法哈希 */
int mulHash(string key) {
long hash = 0;
const int MODULUS = 1000000007;
foreach (char c in key) {
hash = (31 * hash + c) % MODULUS;
}
return (int)hash;
}
[class]{simple_hash}-[func]{xorHash}
/* 异或哈希 */
int xorHash(string key) {
int hash = 0;
const int MODULUS = 1000000007;
foreach (char c in key) {
hash ^= c;
}
return hash & MODULUS;
}
[class]{simple_hash}-[func]{rotHash}
/* 旋转哈希 */
int rotHash(string key) {
long hash = 0;
const int MODULUS = 1000000007;
foreach (char c in key) {
hash = ((hash << 4) ^ (hash >> 28) ^ c) % MODULUS;
}
return (int)hash;
}
```
=== "Swift"
@ -473,7 +505,29 @@ $$
=== "C#"
```csharp title="built_in_hash.cs"
int num = 3;
int hashNum = num.GetHashCode();
// 整数 3 的哈希值为 3;
bool bol = true;
int hashBol = bol.GetHashCode();
// 布尔量 true 的哈希值为 1;
double dec = 3.14159;
int hashDec = dec.GetHashCode();
// 小数 3.14159 的哈希值为 -1340954729;
string str = "Hello 算法";
int hashStr = str.GetHashCode();
// 字符串 Hello 算法 的哈希值为 -586107568;
object[] arr = { 12836, "小哈" };
int hashTup = arr.GetHashCode();
// 数组 [12836, 小哈] 的哈希值为 42931033;
ListNode obj = new ListNode(0);
int hashObj = obj.GetHashCode();
// 节点对象 0 的哈希值为 39053774;
```
=== "Swift"

320
chapter_hashing/hash_collision.md
View file

@ -40,17 +40,6 @@ comments: true
=== "Java"
```java title="hash_map_chaining.java"
/* 键值对 */
class Pair {
public int key;
public String val;
public Pair(int key, String val) {
this.key = key;
this.val = val;
}
}
/* 链式地址哈希表 */
class HashMapChaining {
int size; // 键值对数量
@ -163,17 +152,6 @@ comments: true
=== "C++"
```cpp title="hash_map_chaining.cpp"
/* 键值对 */
struct Pair {
public:
int key;
string val;
Pair(int key, string val) {
this->key = key;
this->val = val;
}
};
/* 链式地址哈希表 */
class HashMapChaining {
private:
@ -280,13 +258,6 @@ comments: true
=== "Python"
```python title="hash_map_chaining.py"
class Pair:
"""键值对"""
def __init__(self, key: int, val: str):
self.key = key
self.val = val
class HashMapChaining:
"""链式地址哈希表"""
@ -370,8 +341,6 @@ comments: true
=== "Go"
```go title="hash_map_chaining.go"
[class]{pair}-[func]{}
/* 链式地址哈希表 */
type hashMapChaining struct {
size int // 键值对数量
@ -499,61 +468,147 @@ comments: true
=== "JavaScript"
```javascript title="hash_map_chaining.js"
[class]{Pair}-[func]{}
[class]{HashMapChaining}-[func]{}
```
=== "TypeScript"
```typescript title="hash_map_chaining.ts"
[class]{Pair}-[func]{}
[class]{HashMapChaining}-[func]{}
```
=== "C"
```c title="hash_map_chaining.c"
[class]{pair}-[func]{}
[class]{hashMapChaining}-[func]{}
```
=== "C#"
```csharp title="hash_map_chaining.cs"
[class]{Pair}-[func]{}
/* 链式地址哈希表 */
class HashMapChaining {
int size; // 键值对数量
int capacity; // 哈希表容量
double loadThres; // 触发扩容的负载因子阈值
int extendRatio; // 扩容倍数
List<List<Pair>> buckets; // 桶数组
[class]{HashMapChaining}-[func]{}
/* 构造方法 */
public HashMapChaining() {
size = 0;
capacity = 4;
loadThres = 2 / 3.0;
extendRatio = 2;
buckets = new List<List<Pair>>(capacity);
for (int i = 0; i < capacity; i++) {
buckets.Add(new List<Pair>());
}
}
/* 哈希函数 */
private int hashFunc(int key) {
return key % capacity;
}
/* 负载因子 */
private double loadFactor() {
return (double)size / capacity;
}
/* 查询操作 */
public string get(int key) {
int index = hashFunc(key);
// 遍历桶，若找到 key 则返回对应 val
foreach (Pair pair in buckets[index]) {
if (pair.key == key) {
return pair.val;
}
}
// 若未找到 key 则返回 null
return null;
}
/* 添加操作 */
public void put(int key, string val) {
// 当负载因子超过阈值时，执行扩容
if (loadFactor() > loadThres) {
extend();
}
int index = hashFunc(key);
// 遍历桶，若遇到指定 key ，则更新对应 val 并返回
foreach (Pair pair in buckets[index]) {
if (pair.key == key) {
pair.val = val;
return;
}
}
// 若无该 key ，则将键值对添加至尾部
buckets[index].Add(new Pair(key, val));
size++;
}
/* 删除操作 */
public void remove(int key) {
int index = hashFunc(key);
// 遍历桶，从中删除键值对
foreach (Pair pair in buckets[index].ToList()) {
if (pair.key == key) {
buckets[index].Remove(pair);
}
}
size--;
}
/* 扩容哈希表 */
private void extend() {
// 暂存原哈希表
List<List<Pair>> bucketsTmp = buckets;
// 初始化扩容后的新哈希表
capacity *= extendRatio;
buckets = new List<List<Pair>>(capacity);
for (int i = 0; i < capacity; i++) {
buckets.Add(new List<Pair>());
}
size = 0;
// 将键值对从原哈希表搬运至新哈希表
foreach (List<Pair> bucket in bucketsTmp) {
foreach (Pair pair in bucket) {
put(pair.key, pair.val);
}
}
}
/* 打印哈希表 */
public void print() {
foreach (List<Pair> bucket in buckets) {
List<string> res = new List<string>();
foreach (Pair pair in bucket) {
res.Add(pair.key + " -> " + pair.val);
}
foreach (string kv in res) {
Console.WriteLine(kv);
}
}
}
}
```
=== "Swift"
```swift title="hash_map_chaining.swift"
[class]{Pair}-[func]{}
[class]{HashMapChaining}-[func]{}
```
=== "Zig"
```zig title="hash_map_chaining.zig"
[class]{Pair}-[func]{}
[class]{HashMapChaining}-[func]{}
```
=== "Dart"
```dart title="hash_map_chaining.dart"
/* 键值对 */
class Pair {
int key;
String val;
Pair(this.key, this.val);
}
/* 链式地址哈希表 */
class HashMapChaining {
late int size; // 键值对数量
@ -687,17 +742,6 @@ comments: true
=== "Java"
```java title="hash_map_open_addressing.java"
/* 键值对 */
class Pair {
public int key;
public String val;
public Pair(int key, String val) {
this.key = key;
this.val = val;
}
}
/* 开放寻址哈希表 */
class HashMapOpenAddressing {
private int size; // 键值对数量
@ -821,15 +865,6 @@ comments: true
=== "C++"
```cpp title="hash_map_open_addressing.cpp"
/* 键值对 */
struct Pair {
int key;
string val;
Pair(int k, string v) : key(k), val(v) {
}
};
/* 开放寻址哈希表 */
class HashMapOpenAddressing {
private:
@ -955,13 +990,6 @@ comments: true
=== "Python"
```python title="hash_map_open_addressing.py"
class Pair:
"""键值对"""
def __init__(self, key: int, val: str):
self.key = key
self.val = val
class HashMapOpenAddressing:
"""开放寻址哈希表"""
@ -1057,8 +1085,6 @@ comments: true
=== "Go"
```go title="hash_map_open_addressing.go"
[class]{pair}-[func]{}
/* 链式地址哈希表 */
type hashMapOpenAddressing struct {
size int // 键值对数量
@ -1195,61 +1221,159 @@ comments: true
=== "JavaScript"
```javascript title="hash_map_open_addressing.js"
[class]{Pair}-[func]{}
[class]{HashMapOpenAddressing}-[func]{}
```
=== "TypeScript"
```typescript title="hash_map_open_addressing.ts"
[class]{Pair}-[func]{}
[class]{HashMapOpenAddressing}-[func]{}
```
=== "C"
```c title="hash_map_open_addressing.c"
[class]{pair}-[func]{}
[class]{hashMapOpenAddressing}-[func]{}
```
=== "C#"
```csharp title="hash_map_open_addressing.cs"
[class]{Pair}-[func]{}
/* 开放寻址哈希表 */
class HashMapOpenAddressing {
int size; // 键值对数量
int capacity; // 哈希表容量
double loadThres; // 触发扩容的负载因子阈值
int extendRatio; // 扩容倍数
Pair[] buckets; // 桶数组
Pair removed; // 删除标记
[class]{HashMapOpenAddressing}-[func]{}
/* 构造方法 */
public HashMapOpenAddressing() {
size = 0;
capacity = 4;
loadThres = 2.0 / 3.0;
extendRatio = 2;
buckets = new Pair[capacity];
removed = new Pair(-1, "-1");
}
/* 哈希函数 */
private int hashFunc(int key) {
return key % capacity;
}
/* 负载因子 */
private double loadFactor() {
return (double)size / capacity;
}
/* 查询操作 */
public string get(int key) {
int index = hashFunc(key);
// 线性探测，从 index 开始向后遍历
for (int i = 0; i < capacity; i++) {
// 计算桶索引，越过尾部返回头部
int j = (index + i) % capacity;
// 若遇到空桶，说明无此 key ，则返回 null
if (buckets[j] == null)
return null;
// 若遇到指定 key ，则返回对应 val
if (buckets[j].key == key && buckets[j] != removed)
return buckets[j].val;
}
return null;
}
/* 添加操作 */
public void put(int key, string val) {
// 当负载因子超过阈值时，执行扩容
if (loadFactor() > loadThres) {
extend();
}
int index = hashFunc(key);
// 线性探测，从 index 开始向后遍历
for (int i = 0; i < capacity; i++) {
// 计算桶索引，越过尾部返回头部
int j = (index + i) % capacity;
// 若遇到空桶、或带有删除标记的桶，则将键值对放入该桶
if (buckets[j] == null || buckets[j] == removed) {
buckets[j] = new Pair(key, val);
size += 1;
return;
}
// 若遇到指定 key ，则更新对应 val
if (buckets[j].key == key) {
buckets[j].val = val;
return;
}
}
}
/* 删除操作 */
public void remove(int key) {
int index = hashFunc(key);
// 线性探测，从 index 开始向后遍历
for (int i = 0; i < capacity; i++) {
// 计算桶索引，越过尾部返回头部
int j = (index + i) % capacity;
// 若遇到空桶，说明无此 key ，则直接返回
if (buckets[j] == null) {
return;
}
// 若遇到指定 key ，则标记删除并返回
if (buckets[j].key == key) {
buckets[j] = removed;
size -= 1;
return;
}
}
}
/* 扩容哈希表 */
private void extend() {
// 暂存原哈希表
Pair[] bucketsTmp = buckets;
// 初始化扩容后的新哈希表
capacity *= extendRatio;
buckets = new Pair[capacity];
size = 0;
// 将键值对从原哈希表搬运至新哈希表
foreach (Pair pair in bucketsTmp) {
if (pair != null && pair != removed) {
put(pair.key, pair.val);
}
}
}
/* 打印哈希表 */
public void print() {
foreach (Pair pair in buckets) {
if (pair != null) {
Console.WriteLine(pair.key + " -> " + pair.val);
} else {
Console.WriteLine("null");
}
}
}
}
```
=== "Swift"
```swift title="hash_map_open_addressing.swift"
[class]{Pair}-[func]{}
[class]{HashMapOpenAddressing}-[func]{}
```
=== "Zig"
```zig title="hash_map_open_addressing.zig"
[class]{Pair}-[func]{}
[class]{HashMapOpenAddressing}-[func]{}
```
=== "Dart"
```dart title="hash_map_open_addressing.dart"
/* 键值对 */
class Pair {
int key;
String val;
Pair(this.key, this.val);
}
/* 开放寻址哈希表 */
class HashMapOpenAddressing {
late int _size; // 键值对数量

6
chapter_searching/binary_search_edge.md
View file

@ -10,7 +10,7 @@ comments: true
给定一个长度为 $n$ 的有序数组 `nums` ，数组可能包含重复元素。请查找并返回元素 `target` 在数组中首次出现的索引。若数组中不包含该元素，则返回 $-1$ 。
## 10.2.1. &nbsp; 简单方法
## 10.2.1. &nbsp; 线性方法
为了查找数组中最左边的 `target` ，我们可以分为两步：
@ -21,11 +21,11 @@ comments: true
<p align="center"> Fig. 线性查找最左边的元素 </p>
这个方法虽然有效，但由于包含线性查找，**其时间复杂度可能会劣化至 $O(n)$** 。
这个方法虽然有效，但由于包含线性查找，时间复杂度为 $O(n)$ ，当存在很多重复的 `target` 时效率较低。
## 10.2.2. &nbsp; 二分方法
实际上，我们可以仅通过二分查找解决以上问题。整体算法流程不变，先计算中点索引 $m$ ，再判断 `target` 和 `nums[m]` 大小关系：
考虑仅使用二分查找解决该问题。整体算法流程不变，先计算中点索引 $m$ ，再判断 `target` 和 `nums[m]` 大小关系：
- 当 `nums[m] < target` 或 `nums[m] > target` 时，说明还没有找到 `target` ，因此采取与上节代码相同的缩小区间操作，**从而使指针 $i$ 和 $j$ 向 `target` 靠近**。
- 当 `nums[m] == target` 时，说明“小于 `target` 的元素”在区间 $[i, m - 1]$ 中，因此采用 $j = m - 1$ 来缩小区间，**从而使指针 $j$ 向小于 `target` 的元素靠近**。

4
chapter_sorting/summary.md
View file

@ -44,6 +44,10 @@ comments: true
回顾原始的快速排序，我们有可能会连续地递归长度较大的数组，最差情况下为 $n, n - 1, n - 2, ..., 2, 1$ ，从而递归深度为 $n$ 。尾递归优化可以避免这种情况的出现。
!!! question "当数组中所有元素都相等时，快速排序的时间复杂度是 $O(n^2)$ 吗？该如何处理这种退化情况？"
是的。这种情况可以考虑通过哨兵划分将数组划分为三个部分：小于、等于、大于基准数。仅向下递归小于和大于的两部分。在该方法下，输入元素全部相等的数组，仅一轮哨兵划分即可完成排序。
!!! question "桶排序的最差时间复杂度为什么是 $O(n^2)$ ？"
最差情况下，所有元素被分至同一个桶中。如果我们采用一个 $O(n^2)$ 算法来排序这些元素，则时间复杂度为 $O(n^2)$ 。