Fixed some problems, indentation and Pointer

codes/go/chapter_hashing/array_hash_map.go

@@ -6,91 +6,91 @@ package chapter_hashing
 
 import "fmt"
 
-// 键值对 int->String
+/* 键值对 int->String */
 type Entry struct {
 	key int
 	val string
 }
 
-// 基于数组简易实现的哈希表
+/* 基于数组简易实现的哈希表 */
 type ArrayHashMap struct {
-	bucket []Entry
+	bucket []*Entry
 }
 
 func newArrayHashMap() *ArrayHashMap {
 	// 初始化一个长度为 100 的桶（数组）
-	bucket := make([]Entry, 100)
+	bucket := make([]*Entry, 100)
 	return &ArrayHashMap{bucket: bucket}
 }
 
-// 哈希函数
+/* 哈希函数 */
 func (a *ArrayHashMap) hashFunc(key int) int {
 	index := key % 100
 	return index
 }
 
-// 查询操作
+/* 查询操作 */
 func (a *ArrayHashMap) get(key int) string {
 	index := a.hashFunc(key)
 	pair := a.bucket[index]
-	if pair.key == 0 {
-		return ""
+	if pair == nil {
+		return "Not Found"
 	}
 	return pair.val
 }
 
-//  添加操作
+/* 添加操作 */
 func (a *ArrayHashMap) put(key int, val string) {
-	pair := Entry{key: key, val: val}
+	pair := &Entry{key: key, val: val}
 	index := a.hashFunc(key)
 	a.bucket[index] = pair
 }
 
-// 删除操作
+/* 删除操作 */
 func (a *ArrayHashMap) remove(key int) {
 	index := a.hashFunc(key)
 	// 置为空字符，代表删除
-	a.bucket[index] = Entry{}
+	a.bucket[index] = nil
 }
 
-// 获取所有键对
-func (a *ArrayHashMap) entrySet() []Entry {
-	var pairs []Entry
+/* 获取所有键对 */
+func (a *ArrayHashMap) entrySet() []*Entry {
+	var pairs []*Entry
 	for _, pair := range a.bucket {
-		if pair.key != 0 {
+		if pair != nil {
 			pairs = append(pairs, pair)
 		}
 	}
 	return pairs
 }
 
-// 获取所有键
+/* 获取所有键 */
 func (a *ArrayHashMap) keySet() []int {
 	var keys []int
 	for _, pair := range a.bucket {
-		if pair.key != 0 {
+		if pair != nil {
 			keys = append(keys, pair.key)
 		}
 	}
 	return keys
 }
 
-// 获取所有值
+/* 获取所有值 */
 func (a *ArrayHashMap) valueSet() []string {
 	var values []string
 	for _, pair := range a.bucket {
-		if pair.key != 0 {
+		if pair != nil {
 			values = append(values, pair.val)
 		}
 	}
 	return values
 }
 
-// 打印哈希表
+/* 打印哈希表 */
 func (a *ArrayHashMap) print() {
 	for _, pair := range a.bucket {
-		if pair.key != 0 {
+		if pair != nil {
 			fmt.Println(pair.key, "->", pair.val)
 		}
 	}
-}
+}

codes/go/chapter_hashing/array_hash_map_test.go

@@ -11,42 +11,43 @@ import (
 
 func TestArrayHashMap(t *testing.T) {
 	/* 初始化哈希表 */
-	map1 := newArrayHashMap()
+	mapp := newArrayHashMap()
 
 	/* 添加操作 */
 	// 在哈希表中添加键值对 (key, value)
-	map1.put(12836, "小哈")
-	map1.put(15937, "小啰")
-	map1.put(16750, "小算")
-	map1.put(13276, "小法")
-	map1.put(10583, "小鸭")
+	mapp.put(12836, "小哈")
+	mapp.put(15937, "小啰")
+	mapp.put(16750, "小算")
+	mapp.put(13276, "小法")
+	mapp.put(10583, "小鸭")
 	fmt.Println("\n添加完成后，哈希表为\nKey -> Value")
-	map1.print()
+	mapp.print()
 
 	/* 查询操作 */
 	// 向哈希表输入键 key ，得到值 value
-	name := map1.get(15937)
+	name := mapp.get(15937)
 	fmt.Println("\n输入学号 15937 ，查询到姓名 " + name)
 
 	/* 删除操作 */
 	// 在哈希表中删除键值对 (key, value)
-	map1.remove(10583)
+	mapp.remove(10583)
 	fmt.Println("\n删除 10583 后，哈希表为\nKey -> Value")
-	map1.print()
+	mapp.print()
 
 	/* 遍历哈希表 */
 	fmt.Println("\n遍历键值对 Key->Value")
-	for _, kv := range map1.entrySet() {
+	for _, kv := range mapp.entrySet() {
 		fmt.Println(kv.key, " -> ", kv.val)
 	}
 
 	fmt.Println("\n单独遍历键 Key")
-	for _, key := range map1.keySet() {
+	for _, key := range mapp.keySet() {
 		fmt.Println(key)
 	}
 
 	fmt.Println("\n单独遍历值 Value")
-	for _, val := range map1.valueSet() {
+	for _, val := range mapp.valueSet() {
 		fmt.Println(val)
 	}
 }
+

codes/go/chapter_hashing/hash_map_test.go

@@ -10,48 +10,48 @@ import (
 )
 
 func TestHashmap(t *testing.T) {
-	// 初始化哈希表
-	Map := make(map[int]string)
+	/* 初始化哈希表 */
+	mapp := make(map[int]string)
 
-	// 添加操作
+	/* 添加操作 */
 	// 在哈希表中添加键值对 (key, value)
-	Map[12836] = "小哈"
-	Map[15937] = "小啰"
-	Map[16750] = "小算"
-	Map[13276] = "小法"
-	Map[10583] = "小鸭"
+	mapp[12836] = "小哈"
+	mapp[15937] = "小啰"
+	mapp[16750] = "小算"
+	mapp[13276] = "小法"
+	mapp[10583] = "小鸭"
 	fmt.Println("\n添加完成后，哈希表为\nKey -> Value")
-	for key, value := range Map {
+	for key, value := range mapp {
 		fmt.Printf("%d -> %s\n", key, value)
 	}
 
-	// 查询操作
+	/* 查询操作 */
 	// 向哈希表输入键 key ，得到值 value
-	name := Map[15937]
+	name := mapp[15937]
 	fmt.Println("\n输入学号 15937 ，查询到姓名 ", name)
 
-	// 删除操作
+	/* 删除操作 */
 	// 在哈希表中删除键值对 (key, value)
-	delete(Map, 10583)
+	delete(mapp, 10583)
 	fmt.Println("\n删除 10583 后，哈希表为\nKey -> Value")
-	for key, value := range Map {
+	for key, value := range mapp {
 		fmt.Printf("%d -> %s\n", key, value)
 	}
 
 	/* 遍历哈希表 */
 	// 遍历键值对 key->value
 	fmt.Println("\n遍历键值对 Key->Value")
-	for key, value := range Map {
+	for key, value := range mapp {
 		fmt.Println(key, "->", value)
 	}
 	// 单独遍历键 key
 	fmt.Println("\n单独遍历键 Key")
-	for key := range Map {
+	for key := range mapp {
 		fmt.Println(key)
 	}
 	// 单独遍历值 value
 	fmt.Println("\n单独遍历值 Value")
-	for _, value := range Map {
+	for _, value := range mapp {
 		fmt.Println(value)
 	}
 }