数据结构中的哈希函数

2025年4月28日 | 阅读24分钟

每天产生的数据量几乎达到150 Zettabytes，相当于150万亿Gigabytes。随着数据量的飞速增长，需要一种有效且高效的方式来存储这些数据。所谓有效和高效的方式，是指一种能够以最少的时间检索数据的存储方式，因为操作所需的时间越多，与该操作相关的成本就越高。因此，为了降低操作成本并以高效的方式完成任务，我们需要减少特定任务的数据检索时间。而减少检索时间的解决方案就是哈希函数或哈希表。哈希函数用于将数据映射或绑定到特定的哈希值，然后该哈希值将用作索引或键，将该值存储在哈希表中。将数据存储在哈希表中的主要好处是，哈希表中存储数据的检索时间是单位时间。这意味着存储在哈希表中的数据可以以O(1)的时间复杂度读取。因此，哈希表在大幅缩短从哈希表中读取数据所需的时间方面发挥着重要作用。而哈希表的运行需要哈希函数。现在让我们看看什么是哈希函数以及它是如何工作的。

哈希函数可以定义为一种算法或函数，用于将较大尺寸或长度的数据映射或转换为固定尺寸或小的索引或哈希值。换句话说，哈希函数可以定义为一种算法，用于将较高长度或尺寸的数据转换为固定范围或尺寸内的数据。

传递给哈希函数的输入参数是需要映射到某些哈希数据的数据。哈希函数提供的输出或结果表示与该输入参数值关联的哈希值或哈希。哈希函数与实际在内存中存储数据的哈希表相关联，而哈希函数仅用于将这些值映射到哈希表。由哈希函数为作为输入参数传递的数据项返回的哈希值随后用作索引，将该输入数据映射或存储到哈希表中。或者，我们可以说，由哈希函数为作为输入参数传递的数据项返回的哈希值用作存储该数据的键，这将有助于轻松高效地检索存储的数据。

为了使理想的哈希函数能够工作，它应该满足两个基本属性或条件，以便在指定的计算周期内提供最佳结果。为了在哈希表中高效地存储数据，一个高效的哈希函数应满足的这两个基本属性或条件是：

首先，哈希函数在计算和提供结果方面应该非常快。速度是影响哈希函数整体效率的主要和关键参数之一。计算结果的速度与哈希函数的效率之间存在反比关系，这意味着计算和提供结果所需的时间越多，哈希函数的效率就越低，反之亦然。因此，理想情况下，需要使计算和提供哈希函数结果所需的时间尽可能短，以保持哈希函数的效率。
一旦实现了生成结果的速度，下一步就是正确准确地提供结果。因此，第二个最重要的参数是哈希函数生成的准确性。因此，要求哈希函数生成的结果应该是唯一的和准确的，因为哈希函数生成的哈希值在对哈希表中的数据进行排序时充当键。因此，生成哈希值的唯一性确保不应将两个数据映射到相同的键或哈希值。这就是为什么生成结果的准确性和唯一性会影响整个哈希函数的效率，而这又会影响在哈希表中存储数据的效率。

在生成输出数据或哈希值以保持哈希函数效率的同时，需要满足哈希函数的这两个主要条件。

与哈希表结合使用时，哈希函数用于存储和检索数据项或数据记录。哈希函数将与键关联的每个数据或记录转换为一个哈希数，该哈希数用于索引哈希表。当要将一个项添加到表中时，哈希码可能会索引一个空槽（也称为存储桶），在这种情况下，该项就添加到表中。使用哈希函数将输入数据映射到哈希表的索引的方式会导致创建不同类型的哈希。在本文中，我们将介绍两种主要的哈希类型，它们各有优缺点。我们将理解的两种主要的哈希类型是链式哈希方法和开放寻址哈希方法。

在链式哈希中，哈希表中存在的每个槽都充当具有该索引作为哈希函数哈希值输出的输入元素的头节点。因此，如果该索引的头节点为空，则数据将添加到该头节点；否则，如果该索引的头节点已经存在数据，则将新传入的数据附加或添加到该头节点之后。简而言之，我们可以说哈希表的索引充当链表的头节点。

例如，如果我们有一个从0开始到9结束的十个索引的哈希表。那么我们有十个单独的链表，所有这十个不同链表的头节点都存储在这个哈希表的索引中。然后使用哈希函数将值映射或存储到这些不同的链表中。

链式哈希的主要好处是我们可以在此格式中存储任意数量的数据。要存储大量数据，我们只需将数据添加到与哈希函数为该数据返回的索引值或哈希值相对应的链表中的最后一个现有对象或数据即可。但是，在链式哈希表中存储更多数据会降低哈希表的数据搜索或数据检索效率。因为例如，如果索引1处的链表中有n个元素，那么搜索或检索该链表中最后一个元素所需的时间将是O(n)，这远大于在哈希表的开放寻址链中搜索或检索数据所需的时间。

在开放寻址哈希表中，计算哈希值或键值，然后将输入数据映射或放置在哈希函数返回的索引值处。链式哈希方法和开放寻址哈希方法的主要区别在于，我们可以在链式哈希技术中添加任意数量的数据，但在开放寻址哈希技术中，添加的数据量等于该哈希表中存在的索引数量。

例如，如果我们有一个从0开始到9结束的十个索引的哈希表。那么我们只能在这个类型的哈希表中存储十个数据。

但是，开放寻址哈希表的一个主要好处是，检索存储在哈希表中的数据需要恒定的时间。

除了这些，根据计算逻辑，哈希函数用于创建结果哈希值，还有不同类型的哈希函数。一些主要的哈希函数类型是：

平方取中哈希函数
除法哈希函数
折叠哈希函数

除了上面提到的这些哈希函数，用户还可以使用他们想要实现的任何类型的哈希逻辑，并根据他们的需求创建哈希函数。

让我们通过一个例子来理解哈希的概念以及在整个过程中哈希函数的使用。

假设我们有一个哈希表，有十个槽或索引，从索引值或槽值零(0)开始。最后一个槽值是九(9)。我们在本例中使用的哈希函数是模运算哈希函数，这意味着传递给哈希函数的输入数据将作为哈希的一部分进行模运算，然后该模运算的结果将作为哈希函数的输出返回，该输出将用作索引或槽键，以在哈希表中存储或映射该输入数据。

最初，哈希表看起来是这样的。哈希表中的所有槽都将为空。

槽号	槽中的数据
槽号 0	为空
槽号 1	为空
槽号 2	为空
槽号 3	为空
槽号 4	为空
槽号 5	为空
槽号 6	为空
槽号 7	为空
槽号 8	为空
槽号 9	为空

现在，假设输入数据是25。我们将此输入数据传递给哈希函数。在哈希函数中，执行模运算，25的模运算结果将是5。因此，由哈希函数作为输入数据25的哈希值返回的结果值是5。因此，值为25的输入数据将存储在哈希表槽号5中。添加槽号5中的数据后的哈希表如下：

槽号	槽中的数据
槽号 0	为空
槽号 1	为空
槽号 2	为空
槽号 3	为空
槽号 4	为空
槽号 5	25
槽号 6	为空
槽号 7	为空
槽号 8	为空
槽号 9	为空

现在，假设输入数据是1。我们将此输入数据传递给哈希函数。在哈希函数中，执行模运算，1的模运算结果将是1。因此，由哈希函数作为输入数据1的哈希值返回的结果值是1。因此，值为1的输入数据将存储在哈希表槽号1中。添加槽号1中的数据后的哈希表如下：

槽号	槽中的数据
槽号 0	1
槽号 1	为空
槽号 2	为空
槽号 3	为空
槽号 4	为空
槽号 5	25
槽号 6	为空
槽号 7	为空
槽号 8	68
槽号 9	为空

现在，假设输入数据是493。我们将此输入数据传递给哈希函数。在哈希函数中，执行模运算，493的模运算结果将是3。因此，由哈希函数作为输入数据493的哈希值返回的结果值是3。因此，值为493的输入数据将存储在哈希表槽号3中。添加槽号3中的数据后的哈希表如下：

槽号	槽中的数据
槽号 0	1
槽号 1	为空
槽号 2	493
槽号 3	为空
槽号 4	为空
槽号 5	25
槽号 6	为空
槽号 7	为空
槽号 8	68
槽号 9	为空

因此，这是在向表中添加四次数据后最终哈希表的外观。

现在，假设输入数据是975。我们将此输入数据传递给哈希函数。在哈希函数中，执行模运算，975的模运算结果将是5。因此，由哈希函数作为输入数据975的哈希值返回的结果值是5。因此，值为975的输入数据将存储在哈希表槽号5中。但是槽号5已经被值为25的数据占用。因此，这是开放链式哈希技术的限制，即我们只能在哈希表中存储特定数量的数据。

存储完成后，下一步是从哈希表中检索数据。对于搜索操作，使用相同的哈希函数来查找存储在哈希表中的数据。在搜索操作中，搜索键再次传递给哈希函数，计算出槽号或索引，并检索该索引中的数据，然后将其与搜索键进行匹配。如果搜索键和从哈希表中获取的数据匹配，则搜索操作成功；否则，如果两者都不匹配，则搜索操作不成功。

对于哈希和哈希表的实际实际应用，需要我们通过编程来实现哈希表的概念。因此，为了更好地理解如何通过编程编写哈希表，让我们编写一个Java代码示例，以编程方式模拟哈希表的功能。

代码

// a public class named HashEntry is created that will consist of the most basic Functionalities of the Hash Table that we will create
public class HashEntry {

      // The class HashEntry has two private class variables named key and value that will represent the actual key and value stored in the hash Table

      private int key;

      private int value;

      // a parameterized constructor with two parameters that will be used to initialize the class variables
      HashEntry(int key, int value) {

            this.key = key;

            this.value = value;

      }

      // a public Function named getValue to retrieve the value from the object of the HashEntry class is written
      public int getValue() {

            return value;

      }

      // a public Function named setValue to set value to the object of the HashEntry class is written
      public void setValue(int value) {

            this.value = value;

      }

      a public Function named getKey to retrieve the key from the object of the HashEntry class is written     
      public int getKey() {

            return key;

      }

} //end of the HashEntry class

// a public class named DeletedEntry is created that will inherit the base class HashEntry that will have all the Functionalities needed to delete data from the Hash Table
public class DeletedEntry extends HashEntry {

      // a private static variable named entry is created
      private static DeletedEntry entry = null;

      // a private default constructor is created that will call the parent constructor with the use of super() Function
      private DeletedEntry() {

            super(-1, -1);

      }

      // logic for finding the unique entry that needs to be deleted
      public static DeletedEntry getUniqueDeletedEntry() {

            if (entry == null)

                  entry = new DeletedEntry();

            return entry;

      }

}// end of DeletedEntry class

// Scanner class is imported to use input Functionality
import java.util.Scanner;

// a public class named HashMap is created that will consist of all the calling Functions 
public class HashMap {

      // a private int variable named TABLE_SIZE is created that will represent the size of the Hash Table
      private final static int TABLE_SIZE = 128;

      // A static array of the HashEntry objects is created that will act as a Hash Table
      static HashEntry[] table;

      // A default constructor is created to initialize the Hash Table 
      HashMap() {

            table = new HashEntry[TABLE_SIZE];

            for (int i = 0; i < TABLE_SIZE; i++)

                  table[i] = null;

      }

       // a public Function named get() with one parameter  is created that will be used to find data in the hash Table
      public int get(int key) {

            int hash = (key % TABLE_SIZE);

            int initialHash = -1;

            while (hash != initialHash

                        && (table[hash] == DeletedEntry.getUniqueDeletedEntry() || table[hash] != null

                                   && table[hash].getKey() != key)) {

                  if (initialHash == -1)

                        initialHash = hash;

                  hash = (hash + 1) % TABLE_SIZE;

            }

            if (table[hash] == null || hash == initialHash)
                  // if key is not found in the hash Table then -1 is returned
                  return -1;

            else
                  // if the search key is present in the hash Table then the value associated with that key is returned
                  return table[hash].getValue();

      }

      // a public Function named put() with two parameters is created to add new data in the hash Table
      public void put(int key, int value) {

            // hash value is calculated by modulus operation
            int hash = (key % TABLE_SIZE);

            int initialHash = -1;

            int indexOfDeletedEntry = -1;

            while (hash != initialHash

                        && (table[hash] == DeletedEntry.getUniqueDeletedEntry() || table[hash] != null

                                   && table[hash].getKey() != key)) {

                  if (initialHash == -1)

                        initialHash = hash;

                  if (table[hash] == DeletedEntry.getUniqueDeletedEntry())

                        indexOfDeletedEntry = hash;

                  hash = (hash + 1) % TABLE_SIZE;

            }

            if ((table[hash] == null || hash == initialHash)

                        && indexOfDeletedEntry != -1)

                  table[indexOfDeletedEntry] = new HashEntry(key, value);

            else if (initialHash != hash)

                  if (table[hash] != DeletedEntry.getUniqueDeletedEntry()

                             && table[hash] != null && table[hash].getKey() == key)

                        table[hash].setValue(value);

                  else

                        table[hash] = new HashEntry(key, value);

      }

      // a public Function named remove() with one parameter is created that will be used to delete or remove data from the Hash Table
      public void remove(int key) {

            int hash = (key % TABLE_SIZE);

            int initialHash = -1;

            while (hash != initialHash

                        && (table[hash] == DeletedEntry.getUniqueDeletedEntry() || table[hash] != null

                                   && table[hash].getKey() != key)) {

                  if (initialHash == -1)

                        initialHash = hash;

                  hash = (hash + 1) % TABLE_SIZE;

            }

            if (hash != initialHash && table[hash] != null)

                  table[hash] = DeletedEntry.getUniqueDeletedEntry();

      }

      // a public Function named print_table() with no paramter is created to print the data present in the hash Table
      public static void print_table(){         
            for(int index=0; index<table.length; index++){

                  if(table[index] != null ){

                        if(table[index].getValue() != -1){

                              System.out.println(index +"\t"+table[index].getValue());
                        }
                  }
            }
      }

} // end of HashMap class

// A main class is created to run the program
class Main{

      // main Function 
      public static void main(String[] args) {
          
            // an object of the HashMap class is created
            HashMap hashtable = new HashMap();

            // A Scanner object is created to take input     
            Scanner scan = new Scanner(System.in);

            char ch;

            // Do-while loop
            // Do part for performing actions
            do
            // Menu is displayed
            // LinearProbingHashTable operations performed as
            // per keys Users enter 'y' to continue 'n' if
            // entered by user , the program terminates

            {
                  // Menu
                  // Display messages
                  System.out.println("Please Choose one of the Operations::");
                  System.out.println("1. To Insert Data in the Hash Table.");
                  System.out.println("2. To Insert Data from the Hash Table.");
                  System.out.println("3. To Search Data in the Hash Table.");
                  System.out.println("4. To Remove or Delete Data From the Hash Table.");
                  System.out.println();
                  
                  // Reading integer using nextInt()
                  int choice = scan.nextInt();

                  // Switch case
                  switch (choice) {

                  // Case 1
                  case 1:

                        // Display message
                        System.out.println("Enter the key and value that you want to add to the Hash Table::");
                        int key = scan.nextInt();
                        int value = scan.nextInt();
                        hashtable.put(key,value);
                        System.out.println("Data Added Successfully.");
                        // Break statement to terminate a case
                        break;

                  // Case 2
                  case 2:

                        // Display message
                        System.out.println("Contents of the hash table are::");
                        System.out.println("Key"+"\t"+"Associated Value");
                        System.out.println("-------------------------------");
                        hashtable.print_table();
                        // Break statement to terminate a case
                        break;

                  // Case 3
                  case 3:

                        // Print statements
                        System.out.println("Enter key for which the data you want::");
                        int search_key = scan.nextInt();
                        int result = hashtable.get(search_key);
                        System.out.println("The value associated with the entered key is = " + result);
                        // Break statement to terminate a case
                        break;

                  // Case 4
                  case 4:

                        System.out.println("Enter the key that you want to Delete::");
                        int del_key = scan.nextInt();
                        hashtable.remove(del_key);
                        System.out.println("Data deleted Sucessfully.");
                        // Break statement to terminate a case
                        break;

                  default:
                        // Print statement
                        System.out.println("Please enter a valid option from the menu to proceed further.\n ");
                        // Break statement
                        break;
                  }

                  System.out.println("\nType [N or n] to terminate the program.\nType [Y or y] to continue the program.\n");
                  ch = scan.next().charAt(0);
                  
            } while (!(ch == 'N' || ch == 'n'));
      }

}// end of the main class

输出

Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

1
Enter the key and value that you want to add to the Hash Table::
0
10
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

Y
Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

1
Enter the key and value that you want to add to the Hash Table::
1
85
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

Y
Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

1
Enter the key and value that you want to add to the Hash Table::
3
47
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

Y
Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

1
Enter the key and value that you want to add to the Hash Table::
7
149
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

Y
Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

2
Contents of the hash table are::
Key   Associated Value
-------------------------------
0     10
1     85
3     47
7     149

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

Y
Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

3
Enter key for which the data you want::
3
The value associated with the entered key is = 47

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

Y
Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

4
Enter the key that you want to Delete::
1
Data deleted Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

Y
Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

2
Contents of the hash table are::
Key   Associated Value
-------------------------------
0     10
3     47
7     149

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

N

在上面的代码中，我们首先四次向哈希表添加数据，然后通过打印哈希表的内容来确认插入。之后，我们通过搜索键搜索哈希表中存在的值，并打印获得的结果。最后，通过删除哈希表的内容来执行删除操作，然后通过调用print_data()函数打印更新后的哈希表。

哈希表也可以在C++、Python、JavaScript等其他语言中实现。让我们看一个C++代码示例，其中包含对哈希表执行的所有基本操作。

C++ 代码

// A simple C++ code showing all the properties and Functionalities of a Hash Table

#define NULL 0
#include <iostream>
using namespace std;

// A class named LinkedHashEntry is created that will hold all the utility Functions of the Hash Table
class LinkedHashEntry {

// The class LinkedHashEntry has two private class variables named key and value that will represent the actual key and value stored in the hash Table

private:

      int key;

      int value;

      LinkedHashEntry *next;

public:

      // a parameterized constructor with two parameters that will be used to initialize the class variables
      LinkedHashEntry(int key, int value) {

            this->key = key;

            this->value = value;

            this->next = NULL;

      }

      // a public Function named getKey to retrieve the key from the object of the LinkedHashEntry class is written     
     
      int getKey() {

            return key;

      }

      // a public Function named getValue to retrieve the value from the object of the LinkedHashEntry class is written
      
      int getValue() {

            return value;

      }

      // a public Function named setValue to set the value to the object of the LinkedHashEntry class is written
      
      void setValue(int value) {

            this->value = value;

      }

      LinkedHashEntry *getNext() {

            return next;

      }

      void setNext(LinkedHashEntry *next) {

            this->next = next;

      }

};

// a constant int variable named TABLE_SIZE is created that will represent the size of the Hash Table
const int TABLE_SIZE = 128;

class HashMap {

private:

      // the table variable will represent the actual hash table in this program 
      LinkedHashEntry **table;

public:

       // A default constructor is created to initialize the Hash Table 
      HashMap() {

            table = new LinkedHashEntry*[TABLE_SIZE];

            for (int i = 0; i < TABLE_SIZE; i++)

                  table[i] = NULL;

      }

      // a Function named get() with one parameter  is created that will be used to find data in the hash Table
      
      int get(int key) {

            int hash = (key % TABLE_SIZE);

            if (table[hash] == NULL)

                  return -1;

            else {

                  LinkedHashEntry *entry = table[hash];

                  while (entry != NULL && entry->getKey() != key)

                        entry = entry->getNext();

                  if (entry == NULL)

                        return -1;

                  else

                        return entry->getValue();

            }

      }

       // a  Function named put() with two parameters is created to add new data in the hash Table
      void put(int key, int value) {

            int hash = (key % TABLE_SIZE);

            if (table[hash] == NULL)

                  table[hash] = new LinkedHashEntry(key, value);

            else {

                  LinkedHashEntry *entry = table[hash];

                  while (entry->getNext() != NULL)

                        entry = entry->getNext();

                  if (entry->getKey() == key)

                        entry->setValue(value);

                  else
                        entry->setNext(new LinkedHashEntry(key, value));

            }

      }

      // a  Function named remove() with one parameter is created that will be used to delete or remove data from the Hash Table
      void remove(int key) {

            int hash = (key % TABLE_SIZE);

            if (table[hash] != NULL) {

                  LinkedHashEntry *prevEntry = NULL;

                  LinkedHashEntry *entry = table[hash];

                  while (entry->getNext() != NULL && entry->getKey() != key) {

                        prevEntry = entry;

                        entry = entry->getNext();

                  }

                  if (entry->getKey() == key) {

                        if (prevEntry == NULL) {

                             LinkedHashEntry *nextEntry = entry->getNext();

                             delete entry;

                             table[hash] = nextEntry;

                        } else {

                             LinkedHashEntry *next = entry->getNext();

                              delete entry;

                             prevEntry->setNext(next);

                        }

                  }

            }

      }

      void print_table(){

            for(int i=0; i<TABLE_SIZE; i++){

                  if(table[i] != 0)
                        cout<<i<<"\t"<<table[i]->getValue()<<"\n";
            }

      }
 
      // A destructor is also written that will be used for deleting the objects of the LinkedHashEntry class 
      ~HashMap() {

            for (int i = 0; i < TABLE_SIZE; i++)

                  if (table[i] != NULL) {

                        LinkedHashEntry *prevEntry = NULL;

                        LinkedHashEntry *entry = table[i];

                        while (entry != NULL) {

                             prevEntry = entry;

                             entry = entry->getNext();

                             delete prevEntry;

                        }

                  }

            delete[] table;

      }

};

// int main(){
//       HashMap hasta;

//       hasta.put(10,10);

//       hasta.print_table();
// }

int main(int argc, char const *argv[])
{
      
      HashMap hashtable;
            char ch;

            // Do-while loop
            // Do part for performing actions
            do
            // Menu is displayed
            // LinearProbingHashTable operations performed as
            // per keys Users enter 'y' to continue 'n' if
            // entered by user , the program terminates

            {
                  // Menu
                  // Display messages
                  cout<<"Please Choose one of the Operations::"<<endl;
                  cout<<"1. To Insert Data in the Hash Table."<<endl;
                  cout<<"2. To Insert Data from the Hash Table."<<endl;
                  cout<<"3. To Search Data in the Hash Table."<<endl;
                  cout<<"4. To Remove or Delete Data From the Hash Table."<<endl;
                  cout<<"\n";
                  
                  // Reading integer using nextInt()
                  int choice;
                  cin>>choice;

                  // Switch case
                  switch (choice) {

                  // Case 1
                  case 1:

                        // Display message
                        cout<<"Enter the key and value that you want to add to the Hash Table::"<<endl;
                        int key;
                        int value;
                        cin>>key>>value;
                        hashtable.put(key,value);
                        cout<<"Data Added Sucessfully."<<endl;
                        // Break statement to terminate a case
                        break;

                  // Case 2
                  case 2:

                        // Display message
                        cout<<"Contents of the hash table are::"<<endl;
                        cout<<"Key"<<"\t"<<"Associated Value"<<endl;
                        cout<<"-------------------------------"<<endl;
                        hashtable.print_table();
                        // Break statement to terminate a case
                        break;

                  // Case 3
                  case 3:{

                        // Print statements
                        cout<<"Enter key for which the data you want::"<<endl;
                        int search_key;
                        cin>>search_key;
                        int results = hashtable.get(search_key);
                        cout<<"The value associated with the entered key is = " <<results<<endl;
                        // Break statement to terminate a case
                        }
                        break;

                  // Case 4
                  case 4:

                        cout<<"Enter the key that you want to Delete::"<<endl;
                        int del_key ;
                        cin>>del_key;
                        hashtable.remove(del_key);
                        cout<<"Data deleted Sucessfully."<<endl;
                        // Break statement to terminate a case
                        break;

                  default:
                        // Print statement
                        cout<<"Please enter a valid option from the menu to proceed further.\n "<<endl;
                        // Break statement
                        break;
                  }

                  cout<<"\nType [N or n] to terminate the program.\nType [Y or y] to continue the program.\n";
                  cin>>ch;
                  
            } while (!(ch == 'N' || ch == 'n'));
       
      return 0;
}

输出

Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

1
Enter the key and value that you want to add to the Hash Table::
101
56
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
Y
Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

1
Enter the key and value that you want to add to the Hash Table::
102
87
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
Y
Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

1
Enter the key and value that you want to add to the Hash Table::
104
97
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

2
Contents of the hash table are::
Key	Associated Value
-------------------------------
101	56
102	87
104	97

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

3
Enter key for which the data you want::
102
The value associated with the entered key is = 87

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

4
Enter the key that you want to Delete::
101
Data deleted Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations::
1. To Insert Data in the Hash Table.
2. To Insert Data from the Hash Table.
3. To Search Data in the Hash Table.
4. To Remove or Delete Data From the Hash Table.

2
Contents of the hash table are::
Key	Associated Value
-------------------------------
102	87
104	97

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
n

因此，在此代码中，也遵循了相同的操作顺序，即首先是插入操作，然后是搜索操作，最后是删除或移除操作，并通过在每个步骤之后打印哈希表中存在的内容来验证所有这些操作的结果，以成功完成特定任务。

由于在哈希表中插入和搜索数据需要恒定的时间。哈希表在许多计算机问题领域都有应用。哈希表的一些应用或用例是：

消息摘要是哈希表的一个应用。
密码验证也使用哈希表。
数据结构（编程语言）。
哈希表在同步中起着重要作用。
哈希表在编译器操作中使用。
Rabin-Karp算法可以使用哈希表实现。
哈希表用于链接文件名和路径。

因此，本文简要介绍了什么是哈希函数，如何使用哈希函数向哈希表添加数据，哈希表的主要优点和用例，以及在Java、C++等不同编程语言中实现哈希表。

下一主题数据结构中的哈希表

我们提供所有技术（如 Java 教程、Android、Java 框架）的教程和面试问题

联系信息

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

hr@tpointtech.com

+91-9599086977

关注我们

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

数据结构教程

DS 数组

DS 链表

DS 栈

DS 队列

DS 树

DS 图

DS 搜索

DS 排序

哈希与堆

差异

二叉树

二叉搜索树

AVL 树

单向链表

双向链表

循环链表

循环双向链表

DS 选择题

其他

数据结构中的哈希函数

代码

C++ 代码

相关帖子

数据结构中的哈希表

二项堆

斐波那契堆

堆数据结构

数据结构中的哈希

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器