第七章-查找

在考研数据结构中，常见的查找算法包括线性查找、二分查找、哈希查找和树查找等。这些算法用于在给定的数据集中查找指定的元素，并返回其位置或其他相关信息。

1. 线性查找（Linear Search）：
   线性查找是最简单的查找算法之一。它从数据集的第一个元素开始逐个比较，直到找到目标元素或遍历完整个数据集。线性查找适用于无序数据集，时间复杂度为O(n)，其中n是数据集的大小。

2. 二分查找（Binary Search）：
   二分查找是一种高效的查找算法，要求数据集必须有序。它通过将数据集分成两半并与目标元素进行比较，然后根据比较结果确定目标元素可能存在的区间，不断缩小查找范围直到找到目标元素或确定不存在。二分查找的时间复杂度为O(log n)，其中n是数据集的大小。

3. 哈希查找（Hashing）：
   哈希查找利用哈希函数将元素映射到一个唯一的哈希值，并将元素存储在相应的哈希表中。当需要查找元素时，通过哈希函数计算出目标元素的哈希值，并在哈希表中查找该哈希值对应的位置。哈希查找的平均时间复杂度为O(1)，但在最坏情况下可能达到O(n)，其中n是数据集的大小。

4. 树查找（Tree Search）：
   树查找是基于树结构进行的查找算法，常见的树结构包括二叉搜索树（Binary Search Tree，BST）、平衡二叉搜索树（如AVL树和红黑树）以及B树等。这些树结构具有有序性质，可以通过比较目标元素与当前节点的大小关系来确定查找方向，从而高效地进行查找。树查找的时间复杂度取决于树的高度，平均情况下为O(log n)，其中n是树中节点的数量。

这些查找算法在不同的场景下有不同的适用性。线性查找适用于小型数据集或无序数据集；二分查找适用于有序数据集；哈希查找适用于需要快速插入和查找的场景；树查找适用于动态数据集和需要维护有序性质的场景。在实际应用中，根据具体的需求和数据特点选择合适的查找算法能够提高查找效率。

以下是使用C语言实现上述介绍的几种查找算法的示例代码：

1. 线性查找（Linear Search）：

```c
#include <stdio.h>

int linearSearch(int arr[], int n, int target) {
    for (int i = 0; i < n; i++) {
        if (arr[i] == target) {
            return i;  // 返回目标元素的索引
        }
    }
    return -1;  // 目标元素未找到
}

int main() {
    int arr[] = {2, 5, 1, 9, 7};
    int n = sizeof(arr) / sizeof(arr[0]);
    int target = 9;
    
    int result = linearSearch(arr, n, target);
    if (result == -1) {
        printf("目标元素未找到\n");
    } else {
        printf("目标元素在索引 %d 处\n", result);
    }
    
    return 0;
}
```

2. 二分查找（Binary Search）：

```c
#include <stdio.h>

int binarySearch(int arr[], int low, int high, int target) {
    while (low <= high) {
        int mid = low + (high - low) / 2;
        
        if (arr[mid] == target) {
            return mid;  // 返回目标元素的索引
        } else if (arr[mid] < target) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    
    return -1;  // 目标元素未找到
}

int main() {
    int arr[] = {1, 2, 5, 7, 9};
    int n = sizeof(arr) / sizeof(arr[0]);
    int target = 9;
    
    int result = binarySearch(arr, 0, n - 1, target);
    if (result == -1) {
        printf("目标元素未找到\n");
    } else {
        printf("目标元素在索引 %d 处\n", result);
    }
    
    return 0;
}
```

3. 哈希查找（Hashing）：

```c
#include <stdio.h>

#define SIZE 10

typedef struct {
    int key;
    int value;
} HashNode;

int hashFunction(int key) {
    return key % SIZE;
}

int hashSearch(HashNode hashTable[], int key) {
    int index = hashFunction(key);
    
    if (hashTable[index].key == key) {
        return hashTable[index].value;  // 返回目标元素的值
    }
    
    return -1;  // 目标元素未找到
}

void hashInsert(HashNode hashTable[], int key, int value) {
    int index = hashFunction(key);
    
    hashTable[index].key = key;
    hashTable[index].value = value;
}

int main() {
    HashNode hashTable[SIZE];
    
    hashInsert(hashTable, 5, 50);
    hashInsert(hashTable, 15, 150);
    hashInsert(hashTable, 25, 250);
    
    int target = 15;
    int result = hashSearch(hashTable, target);
    
    if (result == -1) {
        printf("目标元素未找到\n");
    } else {
        printf("目标元素的值为 %d\n", result);
    }
    
    return 0;
}
```

4. 树查找（Tree Search）：

```c
#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;
    
    root = insertNode(root, 5);
    root = insertNode(root, 2);
    root = insertNode(root, 7);
    root = insertNode(root, 1);
    root = insertNode(root, 3);
    
    int target = 3;
    TreeNode* result = searchNode(root, target);
    
    if (result == NULL) {
        printf("目标元素未找到\n");
    } else {
        printf("目标元素 %d 存在\n", target);
    }
    
    return 0;
}
```

这些代码示例展示了如何使用C语言实现线性查找、二分查找、哈希查找和树查找算法。你可以根据需要进行修改和扩展。