Back to Repositories

Testing Hash Collision Resolution Strategies in hello-algo

This test suite validates hash collision handling implementations in Go, examining both chaining and open addressing methods for hash map conflict resolution. It provides comprehensive testing of fundamental hash map operations including insertion, retrieval, and deletion.

Test Coverage Overview

The test suite covers two distinct hash collision resolution strategies: chaining and open addressing.

Key functionality tested includes:

Hash map initialization and setup
Key-value pair insertion operations
Value retrieval by key lookups
Key-value pair deletion operations
Collision handling mechanisms

Implementation Analysis

The testing approach implements two separate test functions (TestHashMapChaining and TestHashMapOpenAddressing) to validate different collision resolution strategies. Each test follows a consistent pattern of initialization, insertion, retrieval, and deletion operations using the Go testing framework.

Technical implementation includes:

Structured test cases with clear setup and verification steps
Direct output validation using fmt.Println for visual verification
Separate test functions for isolated testing of each implementation

Technical Details

Testing tools and configuration:

Go testing framework (testing package)
fmt package for output formatting
Custom hash map implementations (newHashMapChaining and newHashMapOpenAddressing)
Student ID and name pairs as test data
Integrated print functions for hash map state visualization

Best Practices Demonstrated

The test suite demonstrates several testing best practices for hash map implementations.

Notable practices include:

Isolated testing of different collision resolution strategies
Comprehensive operation verification (CRUD operations)
Clear test case organization and structure
Consistent testing patterns across implementations
Visual state verification for debugging purposes

krahets/hello-algo

codes/go/chapter_hashing/hash_collision_test.go

            
// File: hash_collision_test.go
// Created Time: 2022-12-14
// Author: msk397 ([email protected])

package chapter_hashing

import (
	"fmt"
	"testing"
)

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()
}