GATE-CS-2016（套装2）- 问题 27

这是GATE-CS-2016（套装2）中的问题27。这道题目考察了我们对哈希表的理解。 在这个问题中，我们需要设计一个哈希表来存储字符串。每个字符串都是由小写字母组成的，并且所有字符串的长度都不同。 在此问题中，我们需要设计哈希表的一个函数，用于查询字符串是否存在于哈希表中。

哈希表的设计思路

哈希表是一种以键值对的形式存储数据的数据结构。在哈希表中，我们会对键进行哈希，然后将哈希值映射至数组中。这样，在查询时，我们只需要对键进行哈希，就能快速地定位其所在的位置。下面是一个简单的哈希表的代码实现。

class HashTable:
    def __init__(self):
        self.size = 11
        self.slots = [None] * self.size
        self.data = [None] * self.size

    def put(self,key,data):
      hashvalue = self.hashfunction(key,len(self.slots))

      if self.slots[hashvalue] == None:
        self.slots[hashvalue] = key
        self.data[hashvalue] = data
      else:
        if self.slots[hashvalue] == key:
          self.data[hashvalue] = data  #replace
        else:
          nextslot = self.rehash(hashvalue,len(self.slots))
          while self.slots[nextslot] != None and \
                          self.slots[nextslot] != key:
            nextslot = self.rehash(nextslot,len(self.slots))

          if self.slots[nextslot] == None:
            self.slots[nextslot]=key
            self.data[nextslot]=data
          else:
            self.data[nextslot] = data #replace

    def hashfunction(self,key,size):
        return key%size

    def rehash(self,oldhash,size):
        return (oldhash+1)%size

在上述代码中，我们使用了一个哈希函数和一个重新哈希函数，用于实现键的哈希。

字符串哈希表的设计思路

在这个问题中，我们需要将字符串存储在哈希表中。为了实现这个目的，我们可以使用字符串哈希函数。一种常见的字符串哈希函数是BKDR哈希算法。以下是BKDR哈希算法的代码实现。

def BKDRHash(string):
    seed = 131 # 31 131 1313 13131 131313 etc..
    hash = 0
    for i in range(len(string)):
        hash = (hash * seed) + ord(string[i])
    return hash

完整实现的python代码

下面是完整实现的Python代码。

def BKDRHash(string):
    seed = 131 # 31 131 1313 13131 131313 etc..
    hash = 0
    for i in range(len(string)):
        hash = (hash * seed) + ord(string[i])
    return hash

class HashTable:
    def __init__(self):
        self.size = 11       #定义哈希表的大小
        self.slots = [None] * self.size     #定义哈希表的键列表
        self.data = [None] * self.size      #定义哈希表的值列表

    def put(self,key):     #定义哈希表的添加方法
      hashvalue = BKDRHash(key)%self.size   #计算哈希值

      if self.slots[hashvalue] == None:   #如果哈希值为空，则将键和值添加到列表中
        self.slots[hashvalue] = key
        self.data[hashvalue] = True     #True代表存在于哈希表中
      else:
        if self.slots[hashvalue] == key:
          self.data[hashvalue] == True  #如果哈希值等于该键，则键已经存在于哈希表中，将对应的值设置为True
        else:
          nextslot = self.rehash(hashvalue)   #如果哈希值不为空，则继续寻找下一个空位
          while self.slots[nextslot] != None and \
                          self.slots[nextslot] != key:
            nextslot = self.rehash(nextslot)

          if self.slots[nextslot] == None:   #如果找到的下一个位置为空，则将键和值添加到该列表中
            self.slots[nextslot]=key
            self.data[nextslot]=True
          else:
            self.data[nextslot] = True   #如果找到的下一个位置为该键，则键已经存在于哈希表中，将对应的值设置为True

    def hashfunction(self,key,size):   #定义哈希函数
        return BKDRHash(key)%size

    def rehash(self,oldhash):    #定义重新哈希函数
        return (oldhash+1)%self.size

    def search(self, key):    #定义搜索函数
        hashvalue = BKDRHash(key)%self.size
        if self.slots[hashvalue] == key and self.data[hashvalue] == True:
            return True    #如果哈希值与键相同且对应的值为True，则返回True
        else:
            nextslot = self.rehash(hashvalue)
            while self.slots[nextslot] != None and \
                            self.slots[nextslot] != key:
                nextslot = self.rehash(nextslot)

            if self.slots[nextslot] == None:   #如果找到的下一个位置为空，则返回False
                return False
            elif self.data[nextslot] == True:  #如果找到的下一个位置为该键且对应的值为True，则返回True
                return True
            else:
                return False   #如果找到的下一个位置为该键但对应的值不为True，则返回False

这个哈希表有一个put和search函数。使用哈希表时，首先使用put函数将字符串添加到哈希表中。然后，我们使用search函数来查询字符串是否存在于哈希表中。如果结果为True，则该字符串存在于哈希表中，否则不存在。

总结

哈希表是一种非常有用的数据结构，它可以应用于许多地方。在这个问题中，我们学习了如何设计一个字符串哈希表。在实现字符串哈希表时，我们使用了BKDR哈希算法来计算哈希值。此外，我们还编写了一个哈希表的put和search函数来实现字符串的添加和查询。