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};
    int n = sizeof(arr) / sizeof(arr[0]);
    int target = 7;
    int result = binarySearch(arr, n, target);
    
    if (result != -1) {
        printf("找到了，索引为：%d\n", result);
    } else {
        printf("未找到\n");
    }
    
    return 0;
}

二、二叉排序树查找的C语言实现：

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

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

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

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

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

int main() {
    int nums[] = {5, 3, 8, 2, 4, 7, 9};
    int n = sizeof(nums) / sizeof(nums[0]);
    TreeNode* root = NULL;
    
    for (int i = 0; i < n; i++) {
        root = insert(root, nums[i]);
    }
    
    int target = 7;
    TreeNode* result = search(root, target);
    
    if (result != NULL) {
        printf("找到了，值为：%d\n", result->val);
    } else {
        printf("未找到\n");
    }
    
    return 0;
}

三、哈希表查找的C语言实现：

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

#define TABLE_SIZE 10

typedef struct Node {
    char name[20];
    struct Node* next;
} Node;

Node* hashTable[TABLE_SIZE];

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

void insert(char* name) {
    int index = hash(name);
    Node* newNode = (Node*)malloc(sizeof(Node));
    strcpy(newNode->name, name);
    newNode->next = NULL;
    
    if (hashTable[index] == NULL) {
        hashTable[index] = newNode;
    } else {
        Node* temp = hashTable[index];
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
    }
}

int search(char* name) {
    int index = hash(name);
    Node* temp = hashTable[index];
    
    while (temp != NULL) {
        if (strcmp(temp->name, name) == 0) {
            return 1;
        }
        temp = temp->next;
    }
    
    return 0;
}

int main() {
    memset(hashTable, 0, sizeof(hashTable));
    
    insert("Alice");
    insert("Bob");
    insert("Charlie");
    
    char* target = "Bob";
    int result = search(target);
    
    if (result) {
        printf("找到了，姓名为：%s\n", target);
    } else {
        printf("未找到\n");
    }
    
    return 0;
}