C语言数据结构查找算法实现：折半查找、二叉排序树查找和哈希表查找

以下是C语言实现上述功能的代码：

一、折半查找算法

#include <stdio.h>

int binarySearch(int arr[], int n, int target) {
    int left = 0, right = n - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

int main() {
    int arr[] = {1, 3, 5, 7, 9, 11, 13, 15};
    int n = sizeof(arr) / sizeof(arr[0]);
    int target = 7;
    int result = binarySearch(arr, n, target);
    if (result == -1) {
        printf("Element not found\n");
    } else {
        printf("Element found at index %d\n", result);
    }
    return 0;
}

二、二叉排序树查找

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

typedef struct TreeNode {
    int data;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

TreeNode* createNode(int data) {
    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

TreeNode* insertNode(TreeNode* root, int data) {
    if (root == NULL) {
        return createNode(data);
    }
    if (data < root->data) {
        root->left = insertNode(root->left, data);
    } else if (data > root->data) {
        root->right = insertNode(root->right, data);
    }
    return root;
}

TreeNode* searchNode(TreeNode* root, int data) {
    if (root == NULL || root->data == data) {
        return root;
    }
    if (data < root->data) {
        return searchNode(root->left, data);
    } else {
        return searchNode(root->right, data);
    }
}

int main() {
    TreeNode* root = NULL;
    int arr[] = {5, 3, 7, 1, 4, 6, 8};
    int n = sizeof(arr) / sizeof(arr[0]);
    for (int i = 0; i < n; i++) {
        root = insertNode(root, arr[i]);
    }
    int target = 4;
    TreeNode* result = searchNode(root, target);
    if (result == NULL) {
        printf("Element not found\n");
    } else {
        printf("Element found\n");
    }
    return 0;
}

三、哈希表查找

#include <stdio.h>
#include <string.h>

#define MAX_SIZE 100

typedef struct {
    char name[20];
    int age;
} Person;

typedef struct {
    Person data[MAX_SIZE];
    int occupied[MAX_SIZE];
} HashTable;

int hashFunction(char* name) {
    int sum = 0;
    for (int i = 0; i < strlen(name); i++) {
        sum += name[i];
    }
    return sum % MAX_SIZE;
}

void insertPerson(HashTable* table, Person person) {
    int index = hashFunction(person.name);
    while (table->occupied[index]) {
        index = (index + 1) % MAX_SIZE;
    }
    table->data[index] = person;
    table->occupied[index] = 1;
}

int searchPerson(HashTable* table, char* name) {
    int index = hashFunction(name);
    int count = 0;
    while (table->occupied[index]) {
        if (strcmp(table->data[index].name, name) == 0) {
            return count + 1;
        }
        index = (index + 1) % MAX_SIZE;
        count++;
    }
    return -1;
}

int main() {
    HashTable table;
    memset(&table, 0, sizeof(table));
    Person p1 = {"Alice", 20};
    Person p2 = {"Bob", 22};
    Person p3 = {"Charlie", 19};
    insertPerson(&table, p1);
    insertPerson(&table, p2);
    insertPerson(&table, p3);
    char name[20] = "Bob";
    int result = searchPerson(&table, name);
    if (result == -1) {
        printf("Person not found\n");
    } else {
        printf("Person found at position %d\n", result);
    }
    return 0;
}