算法入门：搜索算法详解（C语言实现）-CSDN博客

搜索算法是计算机科学中最基础也是最重要的算法类型之一，本文将带你深入浅出地学习两种最基础的搜索算法：线性搜索和二分搜索，并通过C语言实现它们。

一、什么是搜索算法？

搜索算法是用于在数据集合中查找特定元素的算法。在实际编程中，我们经常需要在数组、链表或其他数据结构中查找特定值的位置或判断其是否存在。掌握高效的搜索算法对提升程序性能至关重要。

二、线性搜索（Linear Search）

算法原理

线性搜索是最简单的搜索算法，其核心思想是：从数据结构的第一个元素开始，逐个检查每个元素，直到找到目标元素或遍历完所有元素。

算法特点

适用于无序数组
实现简单直观
时间复杂度为O(n)

C语言实现

#include <stdio.h>

// 线性搜索函数

int linearSearch(int arr[ ], int size, int target) {

    for (int i = 0; i < size; i++) {
        if (arr[i] == target) {
            return i; // 找到目标，返回索引
        }
    }
    return -1; // 未找到目标
}

int main() {

    int arr[ ] = {5, 2, 9, 1, 5, 6};

    int size = sizeof(arr) / sizeof(arr[0]);
    int target = 9;
    
    int result = linearSearch(arr, size, target);
    
    if (result != -1) {
        printf("元素 %d 在数组中的索引为: %d\n", target, result);
    } else {
        printf("元素 %d 不在数组中\n", target);
    }
    
    return 0;
}

时间复杂度分析

情况	时间复杂度	说明
最好情况	O(1)	目标元素在第一个位置
最坏情况	O(n)	目标元素在最后一个位置或不存在
平均情况	O(n)	需要遍历约一半的元素

三、二分搜索（Binary Search）

算法原理

二分搜索是一种高效的搜索算法，其核心思想是：在有序数组中，通过不断缩小搜索范围来查找目标元素。

算法步骤

确定数组的中间位置

将目标值与中间值比较：

相等：返回中间索引
目标值 < 中间值：在左半部分继续搜索
目标值 > 中间值：在右半部分继续搜索

重复上述过程直到找到目标或搜索范围为空

算法特点

仅适用于有序数组
时间复杂度为O(log n)
效率远高于线性搜索

C语言实现（迭代版本）

#include <stdio.h>

// 二分搜索函数（迭代版本）

int binarySearch(int arr[ ], int size, int target) {

    int left = 0;
    int right = size - 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 size = sizeof(arr) / sizeof(arr[0]);
    int target = 11;
    
    int result = binarySearch(arr, size, target);
    
    if (result != -1) {
        printf("元素 %d 在数组中的索引为: %d\n", target, result);
    } else {
        printf("元素 %d 不在数组中\n", target);
    }
    
    return 0;
}

C语言实现（递归版本）

#include <stdio.h>

// 二分搜索函数（递归版本）

int binarySearchRecursive(int arr[ ], int left, int right, int target) {

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

int main() {

    int arr[ ] = {2, 4, 6, 8, 10, 12, 14, 16};

    int size = sizeof(arr) / sizeof(arr[0]);
    int target = 8;
    
    int result = binarySearchRecursive(arr, 0, size - 1, target);
    
    if (result != -1) {
        printf("元素 %d 在数组中的索引为: %d\n", target, result);
    } else {
        printf("元素 %d 不在数组中\n", target);
    }
    
    return 0;
}

时间复杂度分析

情况	时间复杂度	说明
最好情况	O(1)	目标元素在中间位置
最坏情况	O(log n)	需要不断折半直到找到目标
平均情况	O(log n)	搜索空间每次减半

四、两种搜索算法对比

特性	线性搜索	二分搜索
前提条件	无	数组必须有序
时间复杂度	O(n)	O(log n)
空间复杂度	O(1)	O(1)（迭代）或 O(log n)（递归）
实现难度	简单	中等
适用场景	小数据集或无序数据	大数据集的有序数据

五、实际应用场景

线性搜索适用场景：

小规模数据搜索
无序数据集合
链表等不支持随机访问的数据结构

二分搜索适用场景：

大规模有序数据搜索
数据库索引
游戏中的高效查找（如分数排名）
数值计算（如求平方根）

六、性能测试比较

下面我们通过一个简单的性能测试来比较两种算法的效率差异：

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

// 省略前面的搜索函数实现...

int main() {
    // 创建一个大型有序数组
    const int SIZE = 10000000;
    int* bigArray = (int*)malloc(SIZE * sizeof(int));
    
    for (int i = 0; i < SIZE; i++) {
        bigArray[i] = i * 2; // 生成偶数序列
    }
    
    int target = SIZE * 2 - 2; // 最后一个元素
    
    // 测试二分搜索速度
    clock_t start = clock();
    int result = binarySearch(bigArray, SIZE, target);
    clock_t end = clock();
    double binaryTime = (double)(end - start) / CLOCKS_PER_SEC;
    
    printf("二分搜索耗时: %.6f 秒, 结果: %d\n", binaryTime, result);
    
    // 测试线性搜索速度
    start = clock();
    result = linearSearch(bigArray, SIZE, target);
    end = clock();
    double linearTime = (double)(end - start) / CLOCKS_PER_SEC;
    
    printf("线性搜索耗时: %.6f 秒, 结果: %d\n", linearTime, result);
    
    free(bigArray);
    return 0;
}

预期输出示例：

二分搜索耗时: 0.000012 秒, 结果: 9999999
线性搜索耗时: 0.125678 秒, 结果: 9999999

注意：实际运行时间会因计算机性能而异，但相对差异非常明显

七、常见问题解答

Q1：二分搜索为什么要求数组有序？

A：二分搜索依赖于数组的有序性才能正确判断目标值位于中间元素的左侧还是右侧。如果数组无序，这种判断将失效。

Q2：递归和迭代实现哪个更好？

A：迭代实现通常更优，因为它避免了递归调用的函数栈开销，空间复杂度为O(1)。递归实现代码更简洁但空间复杂度为O(log n)。

Q3：二分搜索中的 mid = (left + right)/2 有什么问题？

A：当left和right都很大时，(left + right)可能会超出整数范围导致溢出。更安全的写法是：mid = left + (right - left)/2

八、总结

线性搜索是最简单的搜索算法，适用于小型或无序数据集
二分搜索是高效的搜索算法，但要求数据集必须有序
在实际应用中，二分搜索比线性搜索快得多，尤其在大数据集上
选择哪种算法取决于数据状态（是否有序）和数据规模

掌握这两种基础搜索算法是学习更高级算法（如哈希表、二叉搜索树等）的重要基础。建议读者动手实现代码并尝试在不同规模的数据集上测试它们的性能差异。

学习建议：

自己动手实现所有代码示例
尝试在无序数组中使用二分搜索，观察会发生什么
修改代码处理重复元素的情况（返回第一个或最后一个出现位置）
探索二分搜索的变体（如查找插入位置、旋转数组搜索等）

希望这篇教程能帮助你建立搜索算法的坚实基础！如果有任何问题，欢迎在评论区留言讨论。