feat(go): support new features with go code (#565)

* feat(go): support hash map chaining

* feat(go): support hash map open address

* feat(go): support simple hash

* feat(go): support top k heap

* feat(go): support subset sum I

* feat(go): support subset sum native

* feat(go): support subset sum II

* fix(go): fix some problem

codes/go/chapter_backtracking/subset_sum_i.go

@@ -0,0 +1,45 @@
+// File: subset_sum_i.go
+// Created Time: 2023-06-24
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+import "sort"
+
+type subsetI struct{}
+
+/* 回溯算法：子集和 I */
+func (s subsetI) backtrack(start, target int, state, choices *[]int, res *[][]int) {
+	// 子集和等于 target 时，记录解
+	if target == 0 {
+		newState := append([]int{}, *state...)
+		*res = append(*res, newState)
+		return
+	}
+	// 遍历所有选择
+	// 剪枝二：从 start 开始遍历，避免生成重复子集
+	for i := start; i < len(*choices); i++ {
+		// 剪枝一：若子集和超过 target ，则直接结束循环
+		// 这是因为数组已排序，后边元素更大，子集和一定超过 target
+		if target-(*choices)[i] < 0 {
+			break
+		}
+		// 尝试：做出选择，更新 target, start
+		*state = append(*state, (*choices)[i])
+		// 进行下一轮选择
+		s.backtrack(i, target-(*choices)[i], state, choices, res)
+		// 回退：撤销选择，恢复到之前的状态
+		*state = (*state)[:len(*state)-1]
+	}
+}
+
+/* 求解子集和 I */
+func subsetSumI(nums []int, target int) [][]int {
+	s := subsetI{}
+	state := make([]int, 0) // 状态（子集）
+	sort.Ints(nums)         // 对 nums 进行排序
+	start := 0              // 遍历起始点
+	res := make([][]int, 0) // 结果列表（子集列表）
+	s.backtrack(start, target, &state, &nums, &res)
+	return res
+}

codes/go/chapter_backtracking/subset_sum_i_naive.go

@@ -0,0 +1,40 @@
+// File: subset_sum_i_naive.go
+// Created Time: 2023-06-24
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+type subset struct{}
+
+/* 回溯算法：子集和 I */
+func (s subset) backtrack(total, target int, state, choices *[]int, res *[][]int) {
+	// 子集和等于 target 时，记录解
+	if target == total {
+		newState := append([]int{}, *state...)
+		*res = append(*res, newState)
+		return
+	}
+	// 遍历所有选择
+	for i := 0; i < len(*choices); i++ {
+		// 剪枝：若子集和超过 target ，则跳过该选择
+		if total+(*choices)[i] > target {
+			continue
+		}
+		// 尝试：做出选择，更新元素和 total
+		*state = append(*state, (*choices)[i])
+		// 进行下一轮选择
+		s.backtrack(total+(*choices)[i], target, state, choices, res)
+		// 回退：撤销选择，恢复到之前的状态
+		*state = (*state)[:len(*state)-1]
+	}
+}
+
+/* 求解子集和 I（包含重复子集） */
+func subsetSumINaive(nums []int, target int) [][]int {
+	s := subset{}
+	state := make([]int, 0) // 状态（子集）
+	total := 0              // 子集和
+	res := make([][]int, 0) // 结果列表（子集列表）
+	s.backtrack(total, target, &state, &nums, &res)
+	return res
+}

codes/go/chapter_backtracking/subset_sum_ii.go

@@ -0,0 +1,50 @@
+// File: subset_sum_ii.go
+// Created Time: 2023-06-24
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+import "sort"
+
+type subsetII struct{}
+
+/* 回溯算法：子集和 II */
+func (s subsetII) backtrack(start, target int, state, choices *[]int, res *[][]int) {
+	// 子集和等于 target 时，记录解
+	if target == 0 {
+		newState := append([]int{}, *state...)
+		*res = append(*res, newState)
+		return
+	}
+	// 遍历所有选择
+	// 剪枝二：从 start 开始遍历，避免生成重复子集
+	// 剪枝三：从 start 开始遍历，避免重复选择同一元素
+	for i := start; i < len(*choices); i++ {
+		// 剪枝一：若子集和超过 target ，则直接结束循环
+		// 这是因为数组已排序，后边元素更大，子集和一定超过 target
+		if target-(*choices)[i] < 0 {
+			break
+		}
+		// 剪枝四：如果该元素与左边元素相等，说明该搜索分支重复，直接跳过
+		if i > start && (*choices)[i] == (*choices)[i-1] {
+			continue
+		}
+		// 尝试：做出选择，更新 target, start
+		*state = append(*state, (*choices)[i])
+		// 进行下一轮选择
+		s.backtrack(i+1, target-(*choices)[i], state, choices, res)
+		// 回退：撤销选择，恢复到之前的状态
+		*state = (*state)[:len(*state)-1]
+	}
+}
+
+/* 求解子集和 II */
+func subsetSumII(nums []int, target int) [][]int {
+	s := subsetII{}
+	state := make([]int, 0) // 状态（子集）
+	sort.Ints(nums)         // 对 nums 进行排序
+	start := 0              // 遍历起始点
+	res := make([][]int, 0) // 结果列表（子集列表）
+	s.backtrack(start, target, &state, &nums, &res)
+	return res
+}

codes/go/chapter_backtracking/subset_sum_test.go

@@ -0,0 +1,56 @@
+// File: subset_sum_test.go
+// Created Time: 2023-06-24
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+import (
+	"fmt"
+	"strconv"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestSubsetSumINaive(t *testing.T) {
+	nums := []int{3, 4, 5}
+	target := 9
+	res := subsetSumINaive(nums, target)
+
+	fmt.Printf("target = " + strconv.Itoa(target) + ", 输入数组 nums = ")
+	PrintSlice(nums)
+
+	fmt.Println("所有和等于 " + strconv.Itoa(target) + " 的子集 res = ")
+	for i := range res {
+		PrintSlice(res[i])
+	}
+	fmt.Println("请注意，该方法输出的结果包含重复集合")
+}
+
+func TestSubsetSumI(t *testing.T) {
+	nums := []int{3, 4, 5}
+	target := 9
+	res := subsetSumI(nums, target)
+
+	fmt.Printf("target = " + strconv.Itoa(target) + ", 输入数组 nums = ")
+	PrintSlice(nums)
+
+	fmt.Println("所有和等于 " + strconv.Itoa(target) + " 的子集 res = ")
+	for i := range res {
+		PrintSlice(res[i])
+	}
+}
+
+func TestSubsetSumII(t *testing.T) {
+	nums := []int{4, 4, 5}
+	target := 9
+	res := subsetSumII(nums, target)
+
+	fmt.Printf("target = " + strconv.Itoa(target) + ", 输入数组 nums = ")
+	PrintSlice(nums)
+
+	fmt.Println("所有和等于 " + strconv.Itoa(target) + " 的子集 res = ")
+	for i := range res {
+		PrintSlice(res[i])
+	}
+}

codes/go/chapter_hashing/hash_map_chaining.go

@@ -0,0 +1,134 @@
+// File: hash_map_chaining.go
+// Created Time: 2023-06-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_hashing
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+/* 链式地址哈希表 */
+type hashMapChaining struct {
+	size        int      // 键值对数量
+	capacity    int      // 哈希表容量
+	loadThres   float64  // 触发扩容的负载因子阈值
+	extendRatio int      // 扩容倍数
+	buckets     [][]pair // 桶数组
+}
+
+/* 构造方法 */
+func newHashMapChaining() *hashMapChaining {
+	buckets := make([][]pair, 4)
+	for i := 0; i < 4; i++ {
+		buckets[i] = make([]pair, 0)
+	}
+	return &hashMapChaining{
+		size:        0,
+		capacity:    4,
+		loadThres:   2 / 3.0,
+		extendRatio: 2,
+		buckets:     buckets,
+	}
+}
+
+/* 哈希函数 */
+func (m *hashMapChaining) hashFunc(key int) int {
+	return key % m.capacity
+}
+
+/* 负载因子 */
+func (m *hashMapChaining) loadFactor() float64 {
+	return float64(m.size / m.capacity)
+}
+
+/* 查询操作 */
+func (m *hashMapChaining) get(key int) string {
+	idx := m.hashFunc(key)
+	bucket := m.buckets[idx]
+	// 遍历桶，若找到 key 则返回对应 val
+	for _, p := range bucket {
+		if p.key == key {
+			return p.val
+		}
+	}
+	// 若未找到 key 则返回空字符串
+	return ""
+}
+
+/* 添加操作 */
+func (m *hashMapChaining) put(key int, val string) {
+	// 当负载因子超过阈值时，执行扩容
+	if m.loadFactor() > m.loadThres {
+		m.extend()
+	}
+	idx := m.hashFunc(key)
+	// 遍历桶，若遇到指定 key ，则更新对应 val 并返回
+	for _, p := range m.buckets[idx] {
+		if p.key == key {
+			p.val = val
+			return
+		}
+	}
+	// 若无该 key ，则将键值对添加至尾部
+	p := pair{
+		key: key,
+		val: val,
+	}
+	m.buckets[idx] = append(m.buckets[idx], p)
+	m.size += 1
+}
+
+/* 删除操作 */
+func (m *hashMapChaining) remove(key int) {
+	idx := m.hashFunc(key)
+	// 遍历桶，从中删除键值对
+	for i, p := range m.buckets[idx] {
+		if p.key == key {
+			// 切片删除
+			m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)
+			break
+		}
+	}
+	m.size -= 1
+}
+
+/* 扩容哈希表 */
+func (m *hashMapChaining) extend() {
+	// 暂存原哈希表
+	tmpBuckets := make([][]pair, len(m.buckets))
+	for i := 0; i < len(m.buckets); i++ {
+		tmpBuckets[i] = make([]pair, len(m.buckets[i]))
+		copy(tmpBuckets[i], m.buckets[i])
+	}
+	// 初始化扩容后的新哈希表
+	m.capacity *= m.extendRatio
+	m.buckets = make([][]pair, m.capacity)
+	for i := 0; i < m.capacity; i++ {
+		m.buckets[i] = make([]pair, 0)
+	}
+	m.size = 0
+	// 将键值对从原哈希表搬运至新哈希表
+	for _, bucket := range tmpBuckets {
+		for _, p := range bucket {
+			m.put(p.key, p.val)
+		}
+	}
+}
+
+/* 打印哈希表 */
+func (m *hashMapChaining) print() {
+	var builder strings.Builder
+
+	for _, bucket := range m.buckets {
+		builder.WriteString("[")
+		for _, p := range bucket {
+			builder.WriteString(strconv.Itoa(p.key) + " -> " + p.val + " ")
+		}
+		builder.WriteString("]")
+		fmt.Println(builder.String())
+		builder.Reset()
+	}
+}

codes/go/chapter_hashing/hash_map_open_addressing.go

@@ -0,0 +1,142 @@
+// File: hash_map_open_addressing.go
+// Created Time: 2023-06-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_hashing
+
+import (
+	"fmt"
+	"strconv"
+)
+
+/* 链式地址哈希表 */
+type hashMapOpenAddressing struct {
+	size        int     // 键值对数量
+	capacity    int     // 哈希表容量
+	loadThres   float64 // 触发扩容的负载因子阈值
+	extendRatio int     // 扩容倍数
+	buckets     []pair  // 桶数组
+	removed     pair    // 删除标记
+}
+
+/* 构造方法 */
+func newHashMapOpenAddressing() *hashMapOpenAddressing {
+	buckets := make([]pair, 4)
+	return &hashMapOpenAddressing{
+		size:        0,
+		capacity:    4,
+		loadThres:   2 / 3.0,
+		extendRatio: 2,
+		buckets:     buckets,
+		removed: pair{
+			key: -1,
+			val: "-1",
+		},
+	}
+}
+
+/* 哈希函数 */
+func (m *hashMapOpenAddressing) hashFunc(key int) int {
+	return key % m.capacity
+}
+
+/* 负载因子 */
+func (m *hashMapOpenAddressing) loadFactor() float64 {
+	return float64(m.size) / float64(m.capacity)
+}
+
+/* 查询操作 */
+func (m *hashMapOpenAddressing) get(key int) string {
+	idx := m.hashFunc(key)
+	// 线性探测，从 index 开始向后遍历
+	for i := 0; i < m.capacity; i++ {
+		// 计算桶索引，越过尾部返回头部
+		j := (idx + 1) % m.capacity
+		// 若遇到空桶，说明无此 key ，则返回 null
+		if m.buckets[j] == (pair{}) {
+			return ""
+		}
+		// 若遇到指定 key ，则返回对应 val
+		if m.buckets[j].key == key && m.buckets[j] != m.removed {
+			return m.buckets[j].val
+		}
+	}
+	// 若未找到 key 则返回空字符串
+	return ""
+}
+
+/* 添加操作 */
+func (m *hashMapOpenAddressing) put(key int, val string) {
+	// 当负载因子超过阈值时，执行扩容
+	if m.loadFactor() > m.loadThres {
+		m.extend()
+	}
+	idx := m.hashFunc(key)
+	// 线性探测，从 index 开始向后遍历
+	for i := 0; i < m.capacity; i++ {
+		// 计算桶索引，越过尾部返回头部
+		j := (idx + i) % m.capacity
+		// 若遇到空桶、或带有删除标记的桶，则将键值对放入该桶
+		if m.buckets[j] == (pair{}) || m.buckets[j] == m.removed {
+			m.buckets[j] = pair{
+				key: key,
+				val: val,
+			}
+			m.size += 1
+			return
+		}
+		// 若遇到指定 key ，则更新对应 val
+		if m.buckets[j].key == key {
+			m.buckets[j].val = val
+		}
+	}
+}
+
+/* 删除操作 */
+func (m *hashMapOpenAddressing) remove(key int) {
+	idx := m.hashFunc(key)
+	// 遍历桶，从中删除键值对
+	// 线性探测，从 index 开始向后遍历
+	for i := 0; i < m.capacity; i++ {
+		// 计算桶索引，越过尾部返回头部
+		j := (idx + 1) % m.capacity
+		// 若遇到空桶，说明无此 key ，则直接返回
+		if m.buckets[j] == (pair{}) {
+			return
+		}
+		// 若遇到指定 key ，则标记删除并返回
+		if m.buckets[j].key == key {
+			m.buckets[j] = m.removed
+			m.size -= 1
+		}
+	}
+}
+
+/* 扩容哈希表 */
+func (m *hashMapOpenAddressing) extend() {
+	// 暂存原哈希表
+	tmpBuckets := make([]pair, len(m.buckets))
+	copy(tmpBuckets, m.buckets)
+
+	// 初始化扩容后的新哈希表
+	m.capacity *= m.extendRatio
+	m.buckets = make([]pair, m.capacity)
+	m.size = 0
+	// 将键值对从原哈希表搬运至新哈希表
+	for _, p := range tmpBuckets {
+		if p != (pair{}) && p != m.removed {
+			m.put(p.key, p.val)
+		}
+	}
+}
+
+/* 打印哈希表 */
+func (m *hashMapOpenAddressing) print() {
+	for _, p := range m.buckets {
+		if p != (pair{}) {
+			fmt.Println(strconv.Itoa(p.key) + " -> " + p.val)
+		} else {
+			fmt.Println("nil")
+		}
+	}
+}

codes/go/chapter_hashing/hash_map_test.go

@@ -6,6 +6,7 @@ package chapter_hashing
 
 import (
 	"fmt"
+	"strconv"
 	"testing"
 
 	. "github.com/krahets/hello-algo/pkg"
@@ -13,43 +14,113 @@ import (
 
 func TestHashmap(t *testing.T) {
 	/* 初始化哈希表 */
-	mapp := make(map[int]string)
+	hmap := make(map[int]string)
 
 	/* 添加操作 */
 	// 在哈希表中添加键值对 (key, value)
-	mapp[12836] = "小哈"
-	mapp[15937] = "小啰"
-	mapp[16750] = "小算"
-	mapp[13276] = "小法"
-	mapp[10583] = "小鸭"
+	hmap[12836] = "小哈"
+	hmap[15937] = "小啰"
+	hmap[16750] = "小算"
+	hmap[13276] = "小法"
+	hmap[10583] = "小鸭"
 	fmt.Println("\n添加完成后，哈希表为\nKey -> Value")
-	PrintMap(mapp)
+	PrintMap(hmap)
 
 	/* 查询操作 */
 	// 向哈希表输入键 key ，得到值 value
-	name := mapp[15937]
+	name := hmap[15937]
 	fmt.Println("\n输入学号 15937 ，查询到姓名 ", name)
 
 	/* 删除操作 */
 	// 在哈希表中删除键值对 (key, value)
-	delete(mapp, 10583)
+	delete(hmap, 10583)
 	fmt.Println("\n删除 10583 后，哈希表为\nKey -> Value")
-	PrintMap(mapp)
+	PrintMap(hmap)
 
 	/* 遍历哈希表 */
 	// 遍历键值对 key->value
 	fmt.Println("\n遍历键值对 Key->Value")
-	for key, value := range mapp {
+	for key, value := range hmap {
 		fmt.Println(key, "->", value)
 	}
 	// 单独遍历键 key
 	fmt.Println("\n单独遍历键 Key")
-	for key := range mapp {
+	for key := range hmap {
 		fmt.Println(key)
 	}
 	// 单独遍历值 value
 	fmt.Println("\n单独遍历值 Value")
-	for _, value := range mapp {
+	for _, value := range hmap {
 		fmt.Println(value)
 	}
 }
+
+func TestHashMapChaining(t *testing.T) {
+	/* 初始化哈希表 */
+	hmap := newHashMapChaining()
+
+	/* 添加操作 */
+	// 在哈希表中添加键值对 (key, value)
+	hmap.put(12836, "小哈")
+	hmap.put(15937, "小啰")
+	hmap.put(16750, "小算")
+	hmap.put(13276, "小法")
+	hmap.put(10583, "小鸭")
+	fmt.Println("\n添加完成后，哈希表为\nKey -> Value")
+	hmap.print()
+
+	/* 查询操作 */
+	// 向哈希表输入键 key ，得到值 value
+	name := hmap.get(15937)
+	fmt.Println("\n输入学号 15937 ，查询到姓名 ", name)
+
+	/* 删除操作 */
+	// 在哈希表中删除键值对 (key, value)
+	hmap.remove(12836)
+	fmt.Println("\n删除 12836 后，哈希表为\nKey -> Value")
+	hmap.print()
+}
+
+func TestHashMapOpenAddressing(t *testing.T) {
+	/* 初始化哈希表 */
+	hmap := newHashMapOpenAddressing()
+
+	/* 添加操作 */
+	// 在哈希表中添加键值对 (key, value)
+	hmap.put(12836, "小哈")
+	hmap.put(15937, "小啰")
+	hmap.put(16750, "小算")
+	hmap.put(13276, "小法")
+	hmap.put(10583, "小鸭")
+	fmt.Println("\n添加完成后，哈希表为\nKey -> Value")
+	hmap.print()
+
+	/* 查询操作 */
+	// 向哈希表输入键 key ，得到值 value
+	name := hmap.get(13276)
+	fmt.Println("\n输入学号 13276 ，查询到姓名 ", name)
+
+	/* 删除操作 */
+	// 在哈希表中删除键值对 (key, value)
+	hmap.remove(16750)
+	fmt.Println("\n删除 16750 后，哈希表为\nKey -> Value")
+	hmap.print()
+}
+
+func TestSimpleHash(t *testing.T) {
+	var hash int
+
+	key := "Hello 算法"
+
+	hash = addHash(key)
+	fmt.Println("加法哈希值为 " + strconv.Itoa(hash))
+
+	hash = mulHash(key)
+	fmt.Println("乘法哈希值为 " + strconv.Itoa(hash))
+
+	hash = xorHash(key)
+	fmt.Println("异或哈希值为 " + strconv.Itoa(hash))
+
+	hash = rotHash(key)
+	fmt.Println("旋转哈希值为 " + strconv.Itoa(hash))
+}

codes/go/chapter_hashing/simple_hash.go

@@ -0,0 +1,55 @@
+// File: simple_hash.go
+// Created Time: 2023-06-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_hashing
+
+import "fmt"
+
+/* 加法哈希 */
+func addHash(key string) int {
+	var hash int64
+	var modulus int64
+
+	modulus = 1000000007
+	for _, b := range []byte(key) {
+		hash = (hash + int64(b)) % modulus
+	}
+	return int(hash)
+}
+
+/* 乘法哈希 */
+func mulHash(key string) int {
+	var hash int64
+	var modulus int64
+
+	modulus = 1000000007
+	for _, b := range []byte(key) {
+		hash = (31*hash + int64(b)) % modulus
+	}
+	return int(hash)
+}
+
+/* 异或哈希 */
+func xorHash(key string) int {
+	hash := 0
+	modulus := 1000000007
+	for _, b := range []byte(key) {
+		fmt.Println(int(b))
+		hash ^= int(b)
+		hash = (31*hash + int(b)) % modulus
+	}
+	return hash & modulus
+}
+
+/* 旋转哈希 */
+func rotHash(key string) int {
+	var hash int64
+	var modulus int64
+
+	modulus = 1000000007
+	for _, b := range []byte(key) {
+		hash = ((hash << 4) ^ (hash >> 28) ^ int64(b)) % modulus
+	}
+	return int(hash)
+}

codes/go/chapter_heap/heap_test.go

@@ -7,6 +7,7 @@ package chapter_heap
 import (
 	"container/heap"
 	"fmt"
+	"strconv"
 	"testing"
 
 	. "github.com/krahets/hello-algo/pkg"
@@ -88,3 +89,13 @@ func TestMyHeap(t *testing.T) {
 	isEmpty := maxHeap.isEmpty()
 	fmt.Printf("\n堆是否为空 %t\n", isEmpty)
 }
+
+func TestTopKHeap(t *testing.T) {
+	/* 初始化堆 */
+	// 初始化大顶堆
+	nums := []int{1, 7, 6, 3, 2}
+	k := 3
+	res := topKHeap(nums, k)
+	fmt.Printf("最大的 " + strconv.Itoa(k) + " 个元素为")
+	PrintHeap(*res)
+}

codes/go/chapter_heap/top_k.go

@@ -0,0 +1,49 @@
+// File: top_k.go
+// Created Time: 2023-06-24
+// Author: Reanon (793584285@qq.com)
+
+package chapter_heap
+
+import "container/heap"
+
+type minHeap []any
+
+func (h *minHeap) Len() int           { return len(*h) }
+func (h *minHeap) Less(i, j int) bool { return (*h)[i].(int) < (*h)[j].(int) }
+func (h *minHeap) Swap(i, j int)      { (*h)[i], (*h)[j] = (*h)[j], (*h)[i] }
+
+// Push heap.Interface 的方法，实现推入元素到堆
+func (h *minHeap) Push(x any) {
+	*h = append(*h, x.(int))
+}
+
+// Pop heap.Interface 的方法，实现弹出堆顶元素
+func (h *minHeap) Pop() any {
+	// 待出堆元素存放在最后
+	last := (*h)[len(*h)-1]
+	*h = (*h)[:len(*h)-1]
+	return last
+}
+
+// Top 获取堆顶元素
+func (h *minHeap) Top() any {
+	return (*h)[0]
+}
+
+func topKHeap(nums []int, k int) *minHeap {
+	h := &minHeap{}
+	heap.Init(h)
+	// 将数组的前 k 个元素入堆
+	for i := 0; i < k; i++ {
+		heap.Push(h, nums[i])
+	}
+	// 从第 k+1 个元素开始，保持堆的长度为 k
+	for i := k; i < len(nums); i++ {
+		// 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+		if nums[i] > h.Top().(int) {
+			heap.Pop(h)
+			heap.Push(h, nums[i])
+		}
+	}
+	return h
+}