编写search函数，功能是利用顺序查找法从数组a的10个元素中对关键字m进行查找。顺序查找法的思路是：从第一个元素开始，从前向后依次与关键字比较，直到找到此元素或查找到数组尾部时结束。若找到，返回此

题目要求编写一个名为search的函数，功能是利用顺序查找法从数组a的10个元素中对关键字m进行查找。顺序查找法的思路是：从第一个元素开始，依次与关键字进行比较，直到找到此元素或查找到数组尾部为止。若找到，返回此元素或元素在数组尾部的位置。若未找到，返回-1。

如果按照顺序查找法的思路，代码可以从第一个元素开始，依次向后依次与关键字进行比较，直到找到此元素或查找到数组尾部为止。如果找到，返回此元素或元素在数组尾部的位置。如果未找到，返回-1。如果找到了，程序直接结束。

相关问题

C语言编写函数进行顺序查找和折半查找

1. 顺序查找函数

顺序查找，也称线性查找，是一种简单的查找算法，它从表的一端开始，顺序地扫描每个元素，直到找到目标元素或扫描完整个表。下面是一个使用C语言实现顺序查找的函数：

int sequentialSearch(int arr[], int n, int key) {
    for (int i = 0; i < n; i++) {
        if (arr[i] == key) {
            return i;
        }
    }
    return -1; //未找到
}

该函数接收一个整型数组`arr`、数组长度`n`和要查找的关键字`key`，返回关键字在数组中的下标（从0开始），如果未找到则返回-1。

2. 折半查找函数

折半查找，也称二分查找，是一种效率较高的查找算法，它要求被查找的数组必须是有序的，通过不断将查找区间折半，缩小查找范围来进行查找。下面是一个使用C语言实现折半查找的函数：

int binarySearch(int arr[], int n, int key) {
    int left = 0, right = n - 1, mid;
    while (left <= right) {
        mid = (left + right) / 2;
        if (arr[mid] == key) {
            return mid;
        } else if (arr[mid] > key) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return -1; //未找到
}

该函数接收一个有序的整型数组`arr`、数组长度`n`和要查找的关键字`key`，返回关键字在数组中的下标（从0开始），如果未找到则返回-1。

C++采用结构体类型描述查找表的存储结构，编写具体函数实现查找表的顺序查找和折半查找等基本操作

下面是关于查找表的顺序查找和折半查找的 C++ 代码实现：

#include <iostream>

using namespace std;

// 定义查找表的存储结构
struct SearchTable {
    int *data;  // 指向查找表的数组
    int length; // 查找表的长度
};

/**
 * 初始化查找表
 * @param st 查找表
 * @param arr 数组
 * @param length 数组长度
 */
void InitSearchTable(SearchTable &st, int arr[], int length) {
    st.data = new int[length];
    for (int i = 0; i < length; i++) {
        st.data[i] = arr[i];
    }
    st.length = length;
}

/**
 * 销毁查找表
 * @param st 查找表
 */
void DestroySearchTable(SearchTable &st) {
    st.length = 0;
    delete[] st.data;
}

/**
 * 查找表的顺序查找
 * @param st 查找表
 * @param key 关键字
 * @return 如果找到，则返回其位置；否则，返回 -1
 */
int SequentialSearch(SearchTable st, int key) {
    for (int i = 0; i < st.length; i++) {
        if (st.data[i] == key) {
            return i;
        }
    }
    return -1;
}

/**
 * 查找表的折半查找
 * @param st 查找表
 * @param key 关键字
 * @return 如果找到，则返回其位置；否则，返回 -1
 */
int BinarySearch(SearchTable st, int key) {
    int low = 0;
    int high = st.length - 1;
    while (low <= high) {
        int mid = (low + high) / 2;
        if (st.data[mid] == key) {
            return mid;
        } else if (st.data[mid] > key) {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    return -1;
}

int main() {
    int arr[] = {1, 3, 4, 6, 7, 8, 9, 11};
    int length = sizeof(arr) / sizeof(int);
    SearchTable st;
    InitSearchTable(st, arr, length);

    // 顺序查找
    int pos = SequentialSearch(st, 7);
    if (pos == -1) {
        cout << "未找到" << endl;
    } else {
        cout << "7 的位置是：" << pos << endl;
    }

    // 折半查找
    pos = BinarySearch(st, 7);
    if (pos == -1) {
        cout << "未找到" << endl;
    } else {
        cout << "7 的位置是：" << pos << endl;
    }

    DestroySearchTable(st);
    return 0;
}

上面代码中，我们定义了一个结构体 `SearchTable` 来表示查找表的存储结构，其中 `data` 指向查找表的数组，`length` 表示查找表的长度。我们还实现了初始化查找表的函数 `InitSearchTable`，销毁查找表的函数 `DestroySearchTable`，以及两种基本操作：顺序查找和折半查找。

顺序查找是从查找表的第一个元素开始，逐个比较关键字和元素值，直到找到或查找完所有元素。如果找到，则返回其位置；否则，返回 -1。

折半查找是先将查找表按关键字大小有序排列，再从中间位置开始，逐个比较关键字和元素值，直到找到或查找完所有元素。如果找到，则返回其位置；否则，返回 -1。

在 `main` 函数中，我们先创建了一个包含 8 个元素的查找表，并对其进行了初始化。然后分别使用顺序查找和折半查找，查找关键字为 7 的元素。最后销毁查找表，释放内存。