数据结构与算法之顺序搜索算法

发布于：2023-09-22 ⋅ 阅读:(156) ⋅ 点赞:(0)

数据结构与算法之顺序搜索算法

顺序搜索，也称线性搜索，是一种简单的搜索算法，从数据结构的第一个元素开始，依次比较每个元素，直到找到所需的元素，或者遍历完整个数据结构。

顺序搜索算法的实现步骤如下：

  1. 从数据结构的第一个元素开始进行比较；
  2. 如果找到所需的元素，返回元素所在的位置；
  3. 如果遍历完整个数据结构都没有找到所需的元素，则返回搜索失败的结果。

顺序搜索算法的时间复杂度为O(n)，其中n为数据结构中元素的数量。由于该算法需要比较每个元素，因此其速度较慢。在大规模数据搜索中，顺序搜索不是一种优秀的选择，但对于小型数据结构或已有序的数据结构，顺序搜索仍然是一种简单可靠的算法。

在这里插入图片描述

一、C 实现顺序搜索算法及代码详解

顺序搜索（Sequential Search），也称线性搜索（Linear Search），是一种简单的搜索算法，它的基本思想是从数据结构的起始位置开始，顺序比较每一个元素，直到找到目标元素或搜索到数据结构的末尾。

下面是 C 语言实现顺序搜索的代码：

#include <stdio.h>

int sequential_search(int *arr, int n, int x)
{
    for (int i = 0; i < n; i++) {
        if (arr[i] == x) {
            return i;
        }
    }
    return -1;
}

int main()
{
    int arr[] = {2, 7, 11, 15, 23, 37, 41, 47, 53, 67};
    int n = sizeof(arr) / sizeof(int);
    int x = 23;
    int pos;

    pos = sequential_search(arr, n, x);

    if (pos != -1) {
        printf("The position of %d is %d.\n", x, pos);
    } else {
        printf("%d not found.\n", x);
    }

    return 0;
}

代码说明：

  1. sequential_search 函数接收三个参数，分别是待搜索的数组 arr、数组长度 n 和目标元素 x。
  2. 在 sequential_search 函数中，使用 for 循环遍历数组，顺序比较每个元素是否等于目标元素 x。
  3. 如果找到目标元素，返回它在数组中的位置。否则返回 -1，表示没找到目标元素。
  4. main 函数中，定义一个待搜索数组，以及目标元素 x 和搜索结果变量 pos。
  5. 调用 sequential_search 函数，将搜索结果保存到 pos 变量中。
  6. 根据搜索结果，输出对应的信息。

以上就是 C 实现顺序搜索算法的示例代码。

二、C++ 实现顺序搜索算法及代码详解

顺序搜索算法（Sequential Search Algorithm），也叫线性搜索算法，是一种简单直观的查找方法。它逐个扫描列表中的元素，直到找到匹配的目标元素为止，或者扫描到列表末尾仍未找到目标元素。

顺序搜索算法的时间复杂度为 O(n)，其中 n 为列表长度。虽然它的时间复杂度较高，但它的实现简单，适用于小型列表的查找。

以下是 C++ 实现顺序搜索算法的代码：

#include <iostream>
#include <vector>

using namespace std;

//顺序搜索算法
int sequentialSearch(vector<int>& arr, int target){
    int n = arr.size();
    for(int i = 0; i < n; i++){
        if(arr[i] == target){
            return i; //返回目标元素的下标
        }
    }
    return -1; //未找到目标元素
}

int main(){
    vector<int> arr = {1, 4, 2, 6, 7, 3, 9, 5, 8};
    int target = 6;
    int index = sequentialSearch(arr, target);
    if(index != -1){
        cout << "目标元素 " << target << " 的下标为 " << index << endl;
    } else {
        cout << "未找到目标元素 " << target << endl;
    }
    return 0;
}

该代码定义了一个 sequentialSearch 函数，它接收一个整型向量 arr 和一个目标元素 target，并返回目标元素在向量中的下标。如果未找到目标元素，则返回 -1。

在主函数中，定义了一个整型向量 arr，它包含了一些待查找的元素。在这个示例中，我们想查找元素 6 的下标。通过调用 sequentialSearch 函数，将目标元素和整型向量作为参数传递，并获得返回的下标值。

最后，根据返回的下标值判断是否找到了目标元素，并输出相应的结果。

运行上述代码，输出结果为：

目标元素 6 的下标为 3

可以看到，顺序搜索算法成功地找到了目标元素，并返回了它在向量中的下标。顺序搜索算法（Sequential Search Algorithm），也叫线性搜索算法，是一种简单直观的查找方法。它逐个扫描列表中的元素，直到找到匹配的目标元素为止，或者扫描到列表末尾仍未找到目标元素。

顺序搜索算法的时间复杂度为 O(n)，其中 n 为列表长度。虽然它的时间复杂度较高，但它的实现简单，适用于小型列表的查找。

以下是 C++ 实现顺序搜索算法的代码：

#include <iostream>
#include <vector>

using namespace std;

//顺序搜索算法
int sequentialSearch(vector<int>& arr, int target){
    int n = arr.size();
    for(int i = 0; i < n; i++){
        if(arr[i] == target){
            return i; //返回目标元素的下标
        }
    }
    return -1; //未找到目标元素
}

int main(){
    vector<int> arr = {1, 4, 2, 6, 7, 3, 9, 5, 8};
    int target = 6;
    int index = sequentialSearch(arr, target);
    if(index != -1){
        cout << "目标元素 " << target << " 的下标为 " << index << endl;
    } else {
        cout << "未找到目标元素 " << target << endl;
    }
    return 0;
}

该代码定义了一个 sequentialSearch 函数，它接收一个整型向量 arr 和一个目标元素 target，并返回目标元素在向量中的下标。如果未找到目标元素，则返回 -1。

在主函数中，定义了一个整型向量 arr，它包含了一些待查找的元素。在这个示例中，我们想查找元素 6 的下标。通过调用 sequentialSearch 函数，将目标元素和整型向量作为参数传递，并获得返回的下标值。

最后，根据返回的下标值判断是否找到了目标元素，并输出相应的结果。

运行上述代码，输出结果为：

目标元素 6 的下标为 3

可以看到，顺序搜索算法成功地找到了目标元素，并返回了它在向量中的下标。顺序搜索算法（Sequential Search Algorithm），也叫线性搜索算法，是一种简单直观的查找方法。它逐个扫描列表中的元素，直到找到匹配的目标元素为止，或者扫描到列表末尾仍未找到目标元素。

顺序搜索算法的时间复杂度为 O(n)，其中 n 为列表长度。虽然它的时间复杂度较高，但它的实现简单，适用于小型列表的查找。

以下是 C++ 实现顺序搜索算法的代码：

#include <iostream>
#include <vector>

using namespace std;

//顺序搜索算法
int sequentialSearch(vector<int>& arr, int target){
    int n = arr.size();
    for(int i = 0; i < n; i++){
        if(arr[i] == target){
            return i; //返回目标元素的下标
        }
    }
    return -1; //未找到目标元素
}

int main(){
    vector<int> arr = {1, 4, 2, 6, 7, 3, 9, 5, 8};
    int target = 6;
    int index = sequentialSearch(arr, target);
    if(index != -1){
        cout << "目标元素 " << target << " 的下标为 " << index << endl;
    } else {
        cout << "未找到目标元素 " << target << endl;
    }
    return 0;
}

该代码定义了一个 sequentialSearch 函数，它接收一个整型向量 arr 和一个目标元素 target，并返回目标元素在向量中的下标。如果未找到目标元素，则返回 -1。

在主函数中，定义了一个整型向量 arr，它包含了一些待查找的元素。在这个示例中，我们想查找元素 6 的下标。通过调用 sequentialSearch 函数，将目标元素和整型向量作为参数传递，并获得返回的下标值。

最后，根据返回的下标值判断是否找到了目标元素，并输出相应的结果。

运行上述代码，输出结果为：

目标元素 6 的下标为 3

可以看到，顺序搜索算法成功地找到了目标元素，并返回了它在向量中的下标。
在这里插入图片描述

三、Java 实现顺序搜索算法及代码详解

顺序搜索算法（也称为线性搜索）是一种简单的搜索算法，它按照顺序逐一比较列表中的每个元素，直到找到所需的元素或搜索完整个列表为止。它的时间复杂度为O(n)，其中n为列表中元素的数量。

以下是用Java实现顺序搜索算法的代码和详细解释：

public class SequentialSearch {

    public static int search(int[] arr, int target) {
        // 循环遍历数组中的每个元素
        for (int i = 0; i < arr.length; i++) {
            // 如果当前元素与目标相等，则返回此索引
            if (arr[i] == target) {
                return i;
            }
        }
        // 如果遍历完成后仍未找到目标，则返回-1
        return -1;
    }

    public static void main(String[] args) {
        // 演示用例
        int[] arr = {7, 3, 9, 2, 5, 1, 8};
        int target = 5;
        int index = search(arr, target);
        if (index == -1) {
            System.out.println("未找到目标");
        } else {
            System.out.println("目标在数组中的索引为：" + index);
        }
    }
}

在以上代码中，我们使用了一个静态方法search来实现顺序搜索算法。它接受两个参数：一个整数数组和一个目标整数，返回目标整数在数组中的索引。如果目标整数不在数组中，则返回-1。

在方法中，我们使用一个for循环来遍历整个数组中的元素。对于每个元素，我们检查它是否与目标整数相等。如果是，则返回此索引。如果循环完成后仍未找到目标，则返回-1。

在main方法中，我们演示了如何使用search方法来搜索一个整数数组中的目标整数。我们创建一个包含一些整数的数组，并指定目标整数为5。然后我们调用search方法并将结果打印到控制台上。

这就是顺序搜索算法的Java实现及代码详解。顺序搜索算法（也称为线性搜索）是一种简单的搜索算法，它按照顺序逐一比较列表中的每个元素，直到找到所需的元素或搜索完整个列表为止。它的时间复杂度为O(n)，其中n为列表中元素的数量。

以下是用Java实现顺序搜索算法的代码和详细解释：

public class SequentialSearch {

    public static int search(int[] arr, int target) {
        // 循环遍历数组中的每个元素
        for (int i = 0; i < arr.length; i++) {
            // 如果当前元素与目标相等，则返回此索引
            if (arr[i] == target) {
                return i;
            }
        }
        // 如果遍历完成后仍未找到目标，则返回-1
        return -1;
    }

    public static void main(String[] args) {
        // 演示用例
        int[] arr = {7, 3, 9, 2, 5, 1, 8};
        int target = 5;
        int index = search(arr, target);
        if (index == -1) {
            System.out.println("未找到目标");
        } else {
            System.out.println("目标在数组中的索引为：" + index);
        }
    }
}

在以上代码中，我们使用了一个静态方法search来实现顺序搜索算法。它接受两个参数：一个整数数组和一个目标整数，返回目标整数在数组中的索引。如果目标整数不在数组中，则返回-1。

在方法中，我们使用一个for循环来遍历整个数组中的元素。对于每个元素，我们检查它是否与目标整数相等。如果是，则返回此索引。如果循环完成后仍未找到目标，则返回-1。

在main方法中，我们演示了如何使用search方法来搜索一个整数数组中的目标整数。我们创建一个包含一些整数的数组，并指定目标整数为5。然后我们调用search方法并将结果打印到控制台上。

这就是顺序搜索算法的Java实现及代码详解。顺序搜索算法（也称为线性搜索）是一种简单的搜索算法，它按照顺序逐一比较列表中的每个元素，直到找到所需的元素或搜索完整个列表为止。它的时间复杂度为O(n)，其中n为列表中元素的数量。

以下是用Java实现顺序搜索算法的代码和详细解释：

public class SequentialSearch {

    public static int search(int[] arr, int target) {
        // 循环遍历数组中的每个元素
        for (int i = 0; i < arr.length; i++) {
            // 如果当前元素与目标相等，则返回此索引
            if (arr[i] == target) {
                return i;
            }
        }
        // 如果遍历完成后仍未找到目标，则返回-1
        return -1;
    }

    public static void main(String[] args) {
        // 演示用例
        int[] arr = {7, 3, 9, 2, 5, 1, 8};
        int target = 5;
        int index = search(arr, target);
        if (index == -1) {
            System.out.println("未找到目标");
        } else {
            System.out.println("目标在数组中的索引为：" + index);
        }
    }
}

在以上代码中，我们使用了一个静态方法search来实现顺序搜索算法。它接受两个参数：一个整数数组和一个目标整数，返回目标整数在数组中的索引。如果目标整数不在数组中，则返回-1。

在方法中，我们使用一个for循环来遍历整个数组中的元素。对于每个元素，我们检查它是否与目标整数相等。如果是，则返回此索引。如果循环完成后仍未找到目标，则返回-1。

在main方法中，我们演示了如何使用search方法来搜索一个整数数组中的目标整数。我们创建一个包含一些整数的数组，并指定目标整数为5。然后我们调用search方法并将结果打印到控制台上。

这就是顺序搜索算法的Java实现及代码详解。

在这里插入图片描述

本文含有隐藏内容，请 开通VIP 后查看

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布