c语言实现顺序查找、折半查找和散列表的查找功能

定制魏：QTWZPW ，获取更多源码等

目录

总体设计

详细设计 

 顺序查找（Linear Search）

折半查找（Binary Search） 

 哈希表查找（Hash Table Search）

运行效果展示

​编辑

 完整代码

---

总体设计

这个程序包含三种查找算法的实现：

1. 顺序查找： 通过单链表存储元素，使用线性搜索来查找目标值。
2. 折半查找： 利用数组存储元素，使用二分搜索来查找目标值。
3. 散列表： 使用数组实现哈希表，利用散列函数和线性探测法解决冲突。

用户可以选择在生成的随机数中查找目标值，程序会根据用户选择的算法来执行相应的查找操作。 

详细设计 

 顺序查找（Linear Search）

顺序查找算法通过遍历链表来查找目标值。以下是该算法的详细设计：

1. 定义函数 linearSearch，接受一个指向链表头节点的指针 head 和目标值 target。
2. 初始化位置变量 pos 为 1，表示当前查找的节点位置。
3. 从链表头节点开始，逐个遍历链表节点。
4. 每次迭代，检查当前节点的数据是否等于目标值。
5. 如果找到目标值，则打印位置，并返回。
6. 如果未找到目标值，则继续遍历下一个节点。
7. 如果遍历完整个链表仍未找到目标值，则打印未找到的提示信息。

折半查找（Binary Search） 

折半查找算法通过对有序数组进行二分搜索来查找目标值。以下是该算法的详细设计：

1. 定义函数 binarySearch，接受一个数组 data、数组长度 length 和目标值 target。
2. 初始化变量 low 和 high 分别为数组的起始位置和结束位置。
3. 在循环中，计算中间位置 mid，并将其与目标值比较。
4. 如果目标值等于中间值，则打印位置并返回。
5. 如果目标值小于中间值，则更新 high 为 mid - 1。
6. 如果目标值大于中间值，则更新 low 为 mid + 1。
7. 重复步骤 3 - 6，直到找到目标值或者 low 大于 high。
8. 如果循环结束时 low 大于 high，则表示未找到目标值，打印未找到的提示信息。

 哈希表查找（Hash Table Search）

哈希表查找算法利用散列函数和线性探测法解决冲突。以下是该算法的详细设计：

1. 定义哈希函数 hashFunction，将键映射到哈希表索引。
2. 定义函数 insertHash，接受键值对并将其插入哈希表中。
3. 在插入过程中，利用线性探测法解决冲突，寻找下一个可用的位置。
4. 定义函数 searchHash，接受目标键并在哈希表中查找。
5. 在查找过程中，利用哈希函数计算索引，然后使用线性探测法遍历哈希表，直到找到目标键或者遍历整个哈希表。
6. 如果找到目标键，则返回其索引，否则返回 -1 表示未找到。

运行效果展示

 完整代码

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

#define MAX_SIZE 100

// 定义单链表节点结构
typedef struct ListNode {
    int data;
    struct ListNode* next;
} ListNode;

// 定义哈希表节点结构
typedef struct {
    int key;
    int data;
} Node;

// 哈希表
Node hashTable[MAX_SIZE];

// 声明函数
void createLinkedList(ListNode** head, int n);
void linearSearch(ListNode* head, int target);
void binarySearch(int data[], int length, int target);
int hashFunction(int key);
void insertHash(int key, int data);
int searchHash(int key);

int main() {
    int choice, target;
    ListNode* head = NULL;
    int dataArray[MAX_SIZE];
    int n;

    srand(time(NULL));

    printf("请输入要生成的随机数数量：");
    scanf("%d", &n);

    createLinkedList(&head, n);

    // 将链表转换为数组
    ListNode* current = head;
    int i = 0;
    while (current != NULL && i < n) {
        dataArray[i++] = current->data;
        current = current->next;
    }

    printf("生成的随机数为：\n");
    for (int j = 0; j < n; j++) {
        printf("%d ", dataArray[j]);
    }
    printf("\n");

    // 将随机数插入哈希表中
    for (int k = 0; k < n; k++) {
        insertHash(dataArray[k], dataArray[k]);
    }

    do {
        printf("\n菜单:\n");
        printf("1. 顺序查找\n");
        printf("2. 折半查找\n");
        printf("3. 哈希表查找\n");
        printf("4. 退出\n");
        printf("请输入您的选择: ");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                printf("请输入要查找的目标值: ");
                scanf("%d", &target);
                linearSearch(head, target);
                break;
            case 2:
                printf("请输入要查找的目标值: ");
                scanf("%d", &target);
                binarySearch(dataArray, n, target);
                break;
            case 3:
                printf("请输入要查找的目标值: ");
                scanf("%d", &target);
                if (searchHash(target) != -1)
                    printf("元素在哈希表中找到。\n");
                else
                    printf("元素在哈希表中未找到。\n");
                break;
            case 4:
                printf("正在退出...\n");
                break;
            default:
                printf("无效的选择!\n");
        }
    } while (choice != 4);

    return 0;
}

// 创建单链表
void createLinkedList(ListNode** head, int n) {
    ListNode* tail = NULL;
    srand(time(NULL));
    for (int i = 0; i < n; ++i) {
        ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
        newNode->data = rand() % 1000;
        newNode->next = NULL;
        if (*head == NULL) {
            *head = newNode;
        } else {
            tail->next = newNode;
        }
        tail = newNode;
    }
}

// 顺序查找
void linearSearch(ListNode* head, int target) {
    int pos = 1;
    ListNode* current = head;
    while (current != NULL) {
        if (current->data == target) {
            printf("元素在位置 %d 找到。\n", pos);
            return;
        }
        current = current->next;
        pos++;
    }
    printf("未找到元素。\n");
}

// 折半查找
void binarySearch(int data[], int length, int target) {
    int low = 0, high = length - 1, mid;
    while (low <= high) {
        mid = (low + high) / 2;
        if (data[mid] == target) {
            printf("元素在位置 %d 找到。\n", mid + 1);
            return;
        } else if (data[mid] < target) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    printf("未找到元素。\n");
}

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

// 插入哈希表
void insertHash(int key, int data) {
    int index = hashFunction(key);
    int originalIndex = index; 
    while (hashTable[index].key != 0 && hashTable[index].key != key) {
        index = (index + 1) % MAX_SIZE;
        if (index == originalIndex) {
            printf("哈希表已满，无法插入新元素。\n");
            return;
        }
    }
    hashTable[index].key = key;
    hashTable[index].data = data;
}

// 在哈希表中查找
int searchHash(int key) {
    int index = hashFunction(key);
    int originalIndex = index; 
    while (hashTable[index].key != 0) {
        if (hashTable[index].key == key)
            return index;
        index = (index + 1) % MAX_SIZE;
        if (index == originalIndex) 
            break;
    }
    return -1; 
}