算法学习笔记：14.线性查找——从原理到实战，涵盖 LeetCode 与考研 408 例题

本文链接：https://blog.youkuaiyun.com/CSBIGDOG/article/details/149222182

在计算机科学中，查找是最基本也最常用的操作之一。而线性查找作为最简单直观的查找算法，是每个程序员入门时必学的基础内容。尽管它的效率并非最高，但因其实现简单、适用范围广，在很多场景下仍被广泛使用。本文将深入剖析线性查找的算法思想、解题思路，结合 LeetCode 例题与 Java 代码实现，并融入考研 408 的考点分析，穿插图片辅助理解，帮助你全面掌握这一基础算法。

线性查找的基本概念

线性查找（Linear Search），又称顺序查找，是一种逐个检查数据结构中元素的查找方法。它的核心逻辑是：从数据结构的第一个元素开始，依次将每个元素与目标值进行比较，直到找到目标值或遍历完所有元素。

例如，在一个整数数组[5, 2, 9, 1, 5, 6]中查找目标值9，线性查找会从第一个元素5开始，依次比较5、2、9，当比较到9时，发现与目标值匹配，查找结束，返回该元素的位置（索引2）。如果目标值不存在于数组中（如查找3），则遍历完所有元素后返回 “未找到” 的标志（如-1）。

线性查找的算法思想

线性查找的算法思想非常简单，基于 “逐一遍历、依次比较” 的策略，具体可以概括为：

初始化指针：从数据结构的第一个元素开始，设置一个指针（或索引），初始值为0（假设从 0 开始计数）。

遍历与比较：将指针指向的元素与目标值进行比较：

- 如果相等，说明找到目标值，返回当前指针位置（索引）。

- 如果不相等，将指针向后移动一位，继续下一次比较。

结束条件：

- 若遍历完所有元素后仍未找到目标值，返回一个表示 “未找到” 的特殊值（如-1）。

- 若在遍历过程中找到目标值，立即返回其位置，提前结束查找。

线性查找的关键特点是 “顺序性” 和 “全面性”—— 它不依赖数据结构的有序性，无论数据是否排序，都能逐个检查每个元素，因此适用于任何线性数据结构（如数组、链表、队列、栈等）。

线性查找的解题思路

使用线性查找解决实际问题时，通常遵循以下步骤：

明确目标与数据结构：确定需要查找的目标值，以及存储数据的数据结构（如数组、列表等）。

遍历数据结构：使用循环（如for循环、while循环）从第一个元素开始遍历。

比较与判断：在循环中，将当前元素与目标值比较：

- 若匹配，记录位置并退出循环。

- 若不匹配，继续循环。

返回结果：根据查找结果，返回目标值的位置（找到时）或 “未找到” 标志（未找到时）。

线性查找的优势在于实现简单，无需对数据进行预处理（如排序），但缺点是效率较低，尤其在数据量较大时，可能需要遍历大量元素。

LeetCode 例题及 Java 代码实现

例题 1：找出数组中的目标值（LeetCode 704 简化版）

给定一个整数数组nums和一个目标值target，请你判断数组中是否存在目标值。如果存在，返回它的索引；否则，返回-1。

解题思路

直接使用线性查找，遍历数组中的每个元素，与目标值比较，找到则返回索引，否则返回-1。

代码实现

public class LinearSearchExample {

    public int search(int[] nums, int target) {

// 遍历数组中的每个元素

        for (int i = 0; i < nums.length; i++) {

// 比较当前元素与目标值

            if (nums[i] == target) {

                return i; // 找到目标值，返回索引

            }

        }

        return -1; // 未找到目标值

    }

    public static void main(String[] args) {

        LinearSearchExample solution = new LinearSearchExample();

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

        int target = 9;

        System.out.println(solution.search(nums, target)); // 输出：2

        target = 3;

        System.out.println(solution.search(nums, target)); // 输出：-1

    }

}

例题 2：找出字符串中第一个匹配项的下标（LeetCode 28 简化版）

给你两个字符串haystack和needle，请你在haystack字符串中找出needle字符串出现的第一个位置（下标从 0 开始）。如果needle不是haystack的一部分，则返回-1。

解题思路

本题可通过线性查找的思想，在haystack中逐个位置检查是否匹配needle。具体来说，从haystack的第i个字符开始，截取长度与needle相同的子串，与needle比较，若匹配则返回i，否则继续遍历，直到haystack剩余长度不足needle长度为止。

代码实现

public class StrStr {

    public int strStr(String haystack, String needle) {

        int n = haystack.length();

        int m = needle.length();

// 若needle为空，返回0（根据题目约定）

        if (m == 0) {

            return 0;

        }

// 遍历haystack，直到剩余长度不足m

        for (int i = 0; i <= n - m; i++) {

            boolean match = true;

// 检查从i开始的子串是否与needle匹配

            for (int j = 0; j < m; j++) {

                if (haystack.charAt(i + j) != needle.charAt(j)) {

                    match = false;

                    break;

                }

            }

            if (match) {

                return i; // 找到匹配位置

            }

        }

        return -1; // 未找到

    }

    public static void main(String[] args) {

        StrStr solution = new StrStr();

        System.out.println(solution.strStr("hello", "ll")); // 输出：2

        System.out.println(solution.strStr("aaaaa", "bba")); // 输出：-1

    }

}

例题 3：检查整数及其两倍数是否存在（LeetCode 1346）

给你一个整数数组arr，请你检查是否存在两个整数N和M，使得N是M的两倍（即N = 2 * M）。更正式地，检查是否存在两个下标i和j（i != j），使得arr[i] = 2 * arr[j]。

解题思路

对于数组中的每个元素arr[j]，使用线性查找检查数组中是否存在2 * arr[j]，且两个元素的下标不同。需要注意处理特殊情况（如0的两倍仍是0，需确保存在至少两个0）。

代码实现

public class CheckIfExist {

    public boolean checkIfExist(int[] arr) {

        int n = arr.length;

        for (int j = 0; j < n; j++) {

            int target = 2 * arr[j];

// 线性查找target是否存在（且下标不同）

            for (int i = 0; i < n; i++) {

                if (i != j && arr[i] == target) {

                    return true;

                }

            }

        }

        return false;

    }

    public static void main(String[] args) {

        CheckIfExist solution = new CheckIfExist();

        System.out.println(solution.checkIfExist(new int[]{10, 2, 5, 3})); // 输出：true（10是5的两倍）

        System.out.println(solution.checkIfExist(new int[]{7, 1, 14, 11})); // 输出：true（14是7的两倍）

        System.out.println(solution.checkIfExist(new int[]{3, 1, 7, 11})); // 输出：false

    }

}

线性查找与考研 408

在计算机考研 408 中，线性查找是数据结构部分的基础考点，主要涉及以下几个方面：

1. 算法原理与实现

考研 408 常考查线性查找的基本原理和实现方式，要求考生能够写出线性查找的伪代码或具体代码（如在数组、链表中实现查找）。例如，给定一个单链表，要求实现线性查找函数，返回目标值所在节点的指针（若不存在则返回null）。

2. 时间复杂度与空间复杂度分析

时间复杂度：

- 最坏情况：目标值不存在于数据结构中，或位于最后一个位置，需要遍历所有n个元素，时间复杂度为O(n)。

- 最好情况：目标值位于第一个位置，只需比较 1 次，时间复杂度为O(1)。

- 平均情况：假设目标值在每个位置的概率相等，平均比较次数为(n + 1) / 2，时间复杂度为O(n)。

空间复杂度：线性查找是原地查找算法，无需额外辅助空间（仅需常数级变量存储索引和目标值），空间复杂度为O(1)。

3. 适用场景与局限性

适用场景：

- 数据量较小的情况（此时效率差异不明显，实现简单更重要）。

- 数据结构无序的情况（无需预处理，直接查找）。

- 数据结构为链表等无法随机访问的结构（线性查找是唯一可行的简单方法）。

局限性：

- 效率低，在大数据量下性能较差（时间复杂度O(n)）。

- 不适合需要频繁查找的场景（此时应使用哈希表、二叉搜索树等高效数据结构）。

4. 与其他查找算法的对比

考研 408 中常将线性查找与二分查找（折半查找）对比，考查两者的差异：

特性	线性查找	二分查找
数据要求	无需排序	必须有序
存储结构	数组、链表均可	仅适用于随机访问结构（如数组）
时间复杂度	O(n)	O(log n)
实现复杂度	简单	较复杂
适用场景	小数据量、无序数据、链表	大数据量、有序数组