C++哈希查找代码

下面是一个基于哈希表的查找代码示例：

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

int main() {
    // 创建哈希表
    unordered_map<string, int> hash_map;
    // 添加元素
    hash_map["John"] = 26;
    hash_map["Alice"] = 21;
    hash_map["Bob"] = 30;
    // 查找元素
    string name = "Alice";
    if (hash_map.find(name) != hash_map.end()) {
        cout << name << " is " << hash_map[name] << " years old." << endl;
    } else {
        cout << name << " not found." << endl;
    }
    return 0;
}

以上代码中，我们使用了 C++ STL 库中的 `unordered_map` 类来实现哈希表。在添加元素时，我们可以使用 `[]` 运算符或者 `insert` 方法。在查找元素时，我们可以使用 `find` 方法，该方法返回一个迭代器，如果元素不存在，则返回哈希表的 `end` 迭代器。

相关问题

C++哈希查找学生信息

可以使用哈希表来实现学生信息的查找，具体步骤如下：

1. 定义一个结构体来表示学生信息，包括学号、姓名、年龄、性别等属性。
2. 定义一个哈希函数，将学生信息的某个属性映射到哈希表的某个位置。
3. 定义一个哈希表结构体，包括哈希表的大小、哈希表的元素个数、哈希表数组等属性。
4. 实现哈希表的插入、删除和查找操作。对于查找操作，先根据哈希函数计算出学生信息所在的哈希表位置，然后在该位置上查找学生信息。

下面是一个简单的示例代码，实现了基于学号的哈希查找功能：

#include <iostream>
#include <string>

using namespace std;

// 定义学生信息结构体
struct Student {
    int id;         // 学号
    string name;    // 姓名
    int age;        // 年龄
    string gender;  // 性别
};

// 定义哈希表结构体
struct HashTable {
    int size;           // 哈希表大小
    int count;          // 哈希表元素个数
    Student* data;      // 哈希表数据数组

    // 哈希函数
    int hash(int id) {
        return id % size;
    }

    // 插入操作
    void insert(Student s) {
        int pos = hash(s.id);
        while (data[pos].id != -1) {    // 线性探测法解决冲突
            pos = (pos + 1) % size;
        }
        data[pos] = s;
        count++;
    }

    // 查找操作
    Student find(int id) {
        int pos = hash(id);
        while (data[pos].id != -1 && data[pos].id != id) {    // 线性探测法查找
            pos = (pos + 1) % size;
        }
        return data[pos];
    }

    // 删除操作
    void remove(int id) {
        int pos = hash(id);
        while (data[pos].id != -1 && data[pos].id != id) {    // 线性探测法查找
            pos = (pos + 1) % size;
        }
        data[pos].id = -1;  // 将该位置的学生信息标记为删除
        count--;
    }
};

int main() {
    HashTable ht;
    ht.size = 100;
    ht.count = 0;
    ht.data = new Student[ht.size];
    for (int i = 0; i < ht.size; i++) {
        ht.data[i].id = -1;     // 初始化哈希表，将所有学生信息的学号设置为-1
    }

    // 插入学生信息
    Student s1 = { 1001, "张三", 18, "男" };
    Student s2 = { 1002, "李四", 19, "女" };
    Student s3 = { 1003, "王五", 20, "男" };
    ht.insert(s1);
    ht.insert(s2);
    ht.insert(s3);

    // 查找学生信息
    Student s = ht.find(1002);
    cout << "学号：" << s.id << "，姓名：" << s.name << "，年龄：" << s.age << "，性别：" << s.gender << endl;

    // 删除学生信息
    ht.remove(1002);
    s = ht.find(1002);
    cout << "学号：" << s.id << "，姓名：" << s.name << "，年龄：" << s.age << "，性别：" << s.gender << endl;

    return 0;
}

C++整数数组的哈希查找代码

以下是C++中整数数组的哈希查找代码示例：

#include <iostream>
using namespace std;

const int MAXSIZE = 100; // 哈希表的最大大小

int hashFunc(int key) {
    return key % MAXSIZE; // 取余哈希
}

int hashSearch(int arr[], int size, int key) {
    int hashTable[MAXSIZE] = {0}; // 初始化哈希表

    for (int i = 0; i < size; i++) {
        int hashIndex = hashFunc(arr[i]); // 计算哈希值
        if (hashTable[hashIndex] == key) { // 找到目标元素
            return i;
        } else if (hashTable[hashIndex] == 0) { // 哈希表该位置为空，说明没有冲突
            hashTable[hashIndex] = arr[i]; // 将元素存入哈希表
        } else { // 出现了哈希冲突，使用线性探测法解决
            int j = hashIndex + 1; // 从下一个位置开始探测
            while (hashTable[j] != 0 && hashTable[j] != key) {
                j = (j + 1) % MAXSIZE; // 取余哈希
            }
            if (hashTable[j] == key) { // 找到目标元素
                return i;
            } else { // 未找到目标元素，将元素存入哈希表
                hashTable[j] = arr[i];
            }
        }
    }

    return -1; // 未找到目标元素
}

int main() {
    int arr[] = {3, 5, 7, 9, 11, 13, 15, 17, 19, 21};
    int size = sizeof(arr) / sizeof(int);
    int key = 15;
    int index = hashSearch(arr, size, key);
    if (index != -1) {
        cout << "找到目标元素 " << key << "，下标为 " << index << endl;
    } else {
        cout << "未找到目标元素 " << key << endl;
    }
    return 0;
}

运行结果：

找到目标元素 15，下标为 6

这里使用了取余哈希和线性探测法来处理哈希冲突。在实际应用中，还可以使用其他哈希算法和解决冲突的方法，具体选择要根据实际情况来定。