go语言数据结构第九篇-哈希表（散列）

概念

哈希表是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做哈希表。

实际需求

google公司的一个上机题：基于哈希表的员工管理系统

有一个公司，当有新员工来报道时，要求将该员工的信息加入（id，名字），当输入该员工的id时，要求查找到该员工的所有信息。

要求：（1）不使用数据库，尽量节省内存，速度越快越好=>哈希表

           （2）添加时，保证按照员工的id从低到高插入

思路分析：

（1）使用链表来实现哈希表，该链表不带表头（即，链表的第一个结点就存放员工信息）

（2）总体示意图：

            说明：一个哈希表中存了7个链表。每个链表中包含了指向了自己的员工链表的头指针。每个员工链表的结点都是结构体，存储了id，名字。

         那么id该放入哪个链表中呢？使用散列函数，如散列函数为：key  =  id % 链表个数 。

        假设id=21，链表个数为7。则21%7=0，key就=0，这个id就放入LinkArr[0]的 链表中。再假设id=8，则8%7=1，key就=1，这个id就放入LinkArr[1]的链表中。

      当查询时id=28的员工信息时，得出key =  28%链表个数7 = 0，那么直接就在LinkArr[0]这个链表中查询就好了，搜索查询速度快了7倍。若使用10个链表，那就快10倍。链表个数越多，速度越快，但同时占用的空间就越大了。

（3）代码中EmpLinkInsert方法解释示意图：

第一种情况：待插入的id在链表中间

              

第二种情况：待插入id在链表最后

                     

 第三种情况，一开始为空链表

       

完整代码实现：

package main
import (
	"fmt"
	"os"
)

//1.定义员工Emp结构体
type Emp struct {
	Id int
	Name string
	Next *Emp
}
//1.1Emp的方法
func (this *Emp) ShowMe() {
	fmt.Printf("在链表%d中，找到id=%d的员工\n", this.Id % 7, this.Id)
}

//2.定义EmpLink结构体
//我们这里的EmpLink 不带表头,即第一个结点就存放员工
type EmpLink struct {
	Head *Emp
}

//2.1添加员工的方法, 保证添加时，编号从小到大
func (this *EmpLink) EmpLinkInsert(emp *Emp) {

	cur := this.Head // 这是辅助指针
	var pre *Emp = nil // 这是一个辅助指针 ，pre始终在cur前面

	//如果当前的EmpLink就是一个空链表
	if this.Head == nil {
		this.Head = emp //员工插入完成
		return
	}

	//如果不是一个空链表,给emp找到对应的位置并插入
	//思路是 让 cur 和 emp 比较，然后让pre 保持在 cur 前面
	for {
		if cur != nil {
			//比较
			if cur.Id > emp.Id {
				//找到位置,cur的前面，pre的后面
				break
			}
			//pre和cur各向后移动一位
			pre = cur //保证同步
			cur = cur.Next
		}else {
			break
		}
	}
	//退出时，将emp插入pre的后面，cur的前面
	pre.Next = emp
	emp.Next = cur

}
//2.2显示链表的信息
func (this *EmpLink) ShowLink(no int) {
	if this.Head == nil {
		fmt.Printf("链表%d 为空\n", no)
		return
	}

	//遍历当前的链表，并显示数据
	cur := this.Head // 辅助的指针
	for {
		if cur != nil {
			fmt.Printf("链表%d:员工id=%d，名字=%s ->", no, cur.Id, cur.Name)
			cur = cur.Next
		} else {
			break
		}
	}
	fmt.Println() //换行处理
}

//2.3根据id查找对应的员工，如果没有就返回nil
func (this *EmpLink) FindEmpById(id int) *Emp {
	cur := this.Head
	for {
		if cur != nil && cur.Id == id {
			return cur
		} else if cur == nil {
			break
		}
		cur = cur.Next
	}
	return nil
}

//3.定义hashtable ,含有一个链表数组
type HashTable struct {
	LinkArr [7]EmpLink
}

//3.1 给HashTable 编写Insert员工的方法.
func (this *HashTable) HashTableInsert(emp *Emp) {
	//使用散列函数，确定将该员工添加到哪个链表
	linkNo := this.HashFun(emp.Id)
	//使用对应的链表添加
	//HashTable这里只做了id散列，真正添加在EmpLink的EmpLinkInsert方法中完成的
	this.LinkArr[linkNo].EmpLinkInsert(emp)
}

//3.2 编写方法，显示hashtable的所有员工
func (this *HashTable) ShowAll() {
	for i := 0; i < len(this.LinkArr); i++ {
		this.LinkArr[i].ShowLink(i)
	}
}

//3.3编写一个散列方法
func (this *HashTable) HashFun(id int) int {
	return id % 7 //得到一个值，就是对于的链表的下标
}

//3.4编写一个方法，完成查找
func (this *HashTable) FindHashTableById (id int) *Emp {
	//使用散列函数，确定将该员工应该在哪个链表
	linkNo := this.HashFun(id)
	return this.LinkArr[linkNo].FindEmpById(id)
}


func main() {

	key := ""
	id := 0
	name := ""
	var hashtable HashTable
	for {
		fmt.Println("===============员工管理系统菜单============")
		fmt.Println("input 表示添加员工")
		fmt.Println("show  表示显示员工")
		fmt.Println("find  表示查找员工")
		fmt.Println("exit  表示退出系统")

		fmt.Println("请输入你的选择")
		fmt.Scanln(&key)

		switch key {

			case "input":
				fmt.Println("输入员工id")
				fmt.Scanln(&id)
				fmt.Println("输入员工name")
				fmt.Scanln(&name)
				emp := &Emp{
					Id : id,
					Name : name,
				}
				hashtable.HashTableInsert(emp)

			case "show":
				hashtable.ShowAll()

			case "find":
				fmt.Println("请输入id号:")
				fmt.Scanln(&id)
				emp := hashtable.FindHashTableById(id)
				if emp == nil {
					fmt.Printf("id=%d 的员工不存在\n", id)
				} else {
					//编写一个方法，显示员工信息
					emp.ShowMe()
				}

			case "exit":
				os.Exit(0)

			default :
				fmt.Println("输入错误")
		}
	}

}

执行结果：