数据结构与算法之哈希搜索算法

哈希搜索算法（Hash Search）也称作哈希查找，是一种根据关键字直接访问数据的查找方法。哈希查找是基于哈希表实现的，哈希表是一种基于数组的数据结构，其中每个元素都与一个唯一的键值相关联。

哈希表是由一个数组和一种哈希函数组成的，哈希函数根据关键字计算出在数组中的位置。哈希函数可以是简单的取模运算，也可以是更复杂的算法。哈希函数的关键是使每个元素的键值能够被映射到数组中唯一的位置。

哈希查找的基本原理是根据关键字计算其在哈希表中的位置，然后直接访问该位置上的元素。如果该位置上的元素不是要查找的元素，则顺序向后查找。由于哈希表中每个元素的位置是唯一的，因此哈希查找的时间复杂度是O(1)，即常数时间。

哈希查找相对于其他查找算法的优势是查找效率高，时间复杂度低，适合处理大量数据。但其缺点是哈希表的构建需要一定的时间和空间，而且处理哈希冲突的方法也会影响查找效率。因此，在实际应用中，需要根据具体情况选择合适的哈希函数和解决冲突的方法。

一、C 实现哈希搜索算法及代码详解

哈希搜索是一种快速查找数据的算法，其核心思想是将数据存储在数组中，并通过一个哈希函数将每个数据项映射到数组中的特定位置。在查找时，通过哈希函数获取数据项存储的位置，然后在该位置查找数据，从而实现快速查找。下面是C语言实现哈希搜索算法的代码详解。

1. 定义哈希表结构体和哈希函数

#define MAX_SIZE 10   // 哈希表大小
struct node {
    int key;  // 数据项
    int value;  // 数据项对应的值
    struct node* next;  // 用于解决哈希冲突的指针
};
struct hashtable {
    struct node* data[MAX_SIZE];  // 哈希表数组
};
typedef struct hashtable* Hashtable;

// 哈希函数
int hash(int key) {
    return key % MAX_SIZE;
}

2. 初始化哈希表

Hashtable initHashtable() {
    Hashtable H = (Hashtable)malloc(sizeof(struct hashtable));
    for (int i = 0; i < MAX_SIZE; i++) {
        H->data[i] = NULL;
    }
    return H;
}

3. 插入数据项

void insertHashtable(Hashtable H, int key, int value) {
    int index = hash(key);
    struct node* p = H->data[index];
    while (p != NULL) {
        if (p->key == key) {
            p->value = value; // 如果该数据项已经存在，则更新其值
            return;
        }
        p = p->next;
    }
    struct node* newNode = (struct node*)malloc(sizeof(struct node));
    newNode->key = key;
    newNode->value = value;
    newNode->next = H->data[index];
    H->data[index] = newNode;
}

4. 查找数据项

int searchHashtable(Hashtable H, int key) {
    int index = hash(key);
    struct node* p = H->data[index];
    while (p != NULL) {
        if (p->key == key) {
            return p->value;
        }
        p = p->next;
    }
    return -1;  // 如果未找到该数据项，返回-1
}

5. 删除数据项

void deleteHashtable(Hashtable H, int key) {
    int index = hash(key);
    struct node* p = H->data[index];
    struct node* prev = NULL;
    while (p != NULL && p->key != key) {
        prev = p;
        p = p->next;
    }
    if (p == NULL) {
        return;  // 如果未找到该数据项，直接返回
    }
    if (prev == NULL) {
        H->data[index] = p->next;
    } else {
        prev->next = p->next;
    }
    free(p);
}

6. 测试代码

#include <stdio.h>
#include <stdlib.h>

int main() {
    Hashtable H = initHashtable();
    
    insertHashtable(H, 1, 10);
    insertHashtable(H, 2, 20);
    insertHashtable(H, 3, 30);
    insertHashtable(H, 4, 40);
    insertHashtable(H, 5, 50);
    insertHashtable(H, 6, 60);

    printf("Value of key 1: %d\n", searchHashtable(H, 1));
    printf("Value of key 2: %d\n", searchHashtable(H, 2));
    printf("Value of key 3: %d\n", searchHashtable(H, 3));
    printf("Value of key 4: %d\n", searchHashtable(H, 4));
    printf("Value of key 5: %d\n", searchHashtable(H, 5));
    printf("Value of key 6: %d\n", searchHashtable(H, 6));

    deleteHashtable(H, 1);
    deleteHashtable(H, 2);

    printf("Value of key 1: %d\n", searchHashtable(H, 1));
    printf("Value of key 2: %d\n", searchHashtable(H, 2));
    printf("Value of key 3: %d\n", searchHashtable(H, 3));
    printf("Value of key 4: %d\n", searchHashtable(H, 4));
    printf("Value of key 5: %d\n", searchHashtable(H, 5));
    printf("Value of key 6: %d\n", searchHashtable(H, 6));

    return 0;
}

执行上述测试代码，输出结果如下：

Value of key 1: 10
Value of key 2: 20
Value of key 3: 30
Value of key 4: 40
Value of key 5: 50
Value of key 6: 60
Value of key 1: -1
Value of key 2: -1
Value of key 3: 30
Value of key 4: 40
Value of key 5: 50
Value of key 6: 60

可以看到，哈希搜索算法可以用于快速查找数据，并且支持插入、删除操作。实际应用中，哈希搜索算法具有较高的效率和良好的扩展性，因此广泛应用于各种领域。

二、C++ 实现哈希搜索算法及代码详解

哈希搜索是一种常用的搜索算法，可以在一定程度上提高搜索效率。在C++中实现哈希搜索算法有以下几个步骤：

步骤一：定义哈希函数

哈希函数是将数据快速映射到哈希表中的关键步骤。哈希函数需要满足以下特点：

• 计算快速，复杂度 O(1)
• 尽可能避免冲突，即不同的键值经过哈希函数后不应该得到同样的结果

在哈希搜索中，通常使用取余法作为哈希函数。取余法的公式如下：

hash(key) = key % size

其中，key为待映射的键值，size为哈希表的大小。

步骤二：定义哈希表结构

哈希表是将数据存储在哈希表中的数据结构。在C++中，可以使用 std::unordered_map 来实现哈希表的功能。

std::unordered_map 是一个关联容器，用于在常数时间内完成键值对的插入、删除和查找操作。它采用了哈希表的数据结构，每个键值对都被映射到一个桶中，桶中有一个链表存储所有的键值对。在哈希表的插入、删除和查找操作中，需要用到哈希函数来确定键值对所在的桶。

步骤三：定义搜索函数

搜索函数是实现哈希搜索的核心算法。在搜索函数中，需要通过哈希函数和哈希表来快速定位目标数据。

搜索函数的实现步骤如下：

• 根据哈希函数计算目标数据在哈希表中的桶号。
• 在该桶中查找目标数据。
• 如果目标数据存在，则返回目标数据的位置，否则返回未找到。

代码实现如下：

#include <iostream>
#include <unordered_map>
#include <vector>
using namespace std;

// 哈希表大小
const int HASH_SIZE = 10007;

// 哈希函数
int my_hash(int key) {
    return key % HASH_SIZE;
}

// 哈希表结构
unordered_map<int, int> hash_table;

// 搜索函数
int hash_search(int target) {
    int bucket = my_hash(target);
    auto it = hash_table.find(bucket);
    if (it != hash_table.end() && it->second == target) {
        return bucket;
    }
    return -1;
}

int main() {
    // 初始化哈希表
    vector<int> nums = {1, 3, 5, 7, 9};
    for (int num : nums) {
        int bucket = my_hash(num);
        hash_table[bucket] = num;
    }

    // 搜索
    int target = 5;
    int index = hash_search(target);
    if (index != -1) {
        cout << "Find " << target << " at bucket " << index << endl;
    } else {
        cout << "Not found " << target << endl;
    }

    return 0;
}

在上面的代码中，我们通过 std::unordered_map 实现了哈希表结构，并使用 my_hash 函数作为哈希函数。搜索函数 hash_search 利用哈希函数和哈希表实现了哈希搜索算法。

三、Java 实现哈希搜索算法及代码详解

哈希搜索算法是一种通过哈希表来实现搜索的算法。哈希表是一种用于实现键（key）和值（value）之间映射关系的数据结构，通过将键值通过哈希函数映射到哈希表中的某个位置，可以快速的进行查找和插入操作。在哈希搜索算法中，我们将搜索过程转化为对哈希表的查找操作，从而提高搜索效率。

下面我们来看一下 Java 中如何实现哈希搜索算法。首先我们需要定义一个哈希函数，将待搜索的值映射到哈希表中的某个位置。这里我们使用简单的取模运算实现哈希函数：

private int hash(int key, int tableSize) {
    return key % tableSize;
}

接下来我们定义一个哈希表类 HashTable，其中包含 put 和 get 两个方法。put 方法用于将值插入到哈希表中，get 方法用于查找某个值是否存在于哈希表中。

public class HashTable {
    private int tableSize;
    private List<Integer>[] table;

    public HashTable(int tableSize) {
        this.tableSize = tableSize;
        table = new ArrayList[tableSize];
        for (int i = 0; i < tableSize; i++) {
            table[i] = new ArrayList<Integer>();
        }
    }

    public void put(int key) {
        int index = hash(key, tableSize);
        table[index].add(key);
    }

    public boolean get(int key) {
        int index = hash(key, tableSize);
        return table[index].contains(key);
    }
}

在上述代码中，我们使用了一个 List 数组来实现哈希表的存储。具体来说，我们将哈希函数的返回值作为数组的下标，并将待插入的值加入到该位置对应的 List 中。在查找时，我们同样使用哈希函数的返回值来定位所查找的值所在的位置，然后在对应的 List 中查找目标值是否存在。

下面我们来看一下如何使用 HashTable 类进行哈希搜索。假设我们要在一个整数数组中查找某个值是否存在，可以按照以下步骤进行：

int[] arr = {1, 3, 5, 7, 9};
HashTable table = new HashTable(10);
for (int i = 0; i < arr.length; i++) {
    table.put(arr[i]);
}
int searchKey = 5;
if (table.get(searchKey)) {
    System.out.println(searchKey + " is found in the array.");
} else {
    System.out.println(searchKey + " is not found in the array.");
}

在上述代码中，我们首先将整数数组中的元素逐个插入到哈希表中。然后我们可以使用哈希表的 get 方法来查找目标值是否存在于哈希表中。

总结一下，哈希搜索算法通过哈希表将搜索过程转化为对哈希表的查找操作，从而提高了搜索的效率。在 Java 中，我们可以使用 List 数组来实现哈希表，使用取模运算来实现哈希函数。