C/C++元素查找并计数和判断

C/C++元素查找并计数和判断算是基础知识了我们要熟练并掌握想到查找元素我们有以下方法:有多种方法可以在C/C++中进行元素查找并计数和判断，以下是几个常用方法我们从数学类型的元素开始：

数据类型元素查找

1. for循环遍历数组：使用for循环遍历数组，逐个比较数组元素，统计满足条件的元素数量。

int count = 0;  //计数器
int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

//查找值为5的元素并计数
for(int i=0; i<10; i++) {
    if(array[i] == 5) {
        count++;
    }
}

if(count > 0) {
    cout << "数组中包含值为5的元素，共" << count << "个" << endl;
} else {
    cout << "数组中不包含值为5的元素" << endl;
}

2. 标准库算法：使用标准库中的算法函数，比如count()和find()。

#include <algorithm>
int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

//查找值为5的元素并计数
int count = std::count(array, array+10, 5);

if(count > 0) {
    cout << "数组中包含值为5的元素，共" << count << "个" << endl;
} else {
    cout << "数组中不包含值为5的元素" << endl;
}

//查找值为5的元素并判断是否存在
bool exists = std::find(array, array+10, 5) != array+10;

if(exists) {
    cout << "数组中包含值为5的元素" << endl;
} else {
    cout << "数组中不包含值为5的元素" << endl;
}

3. 二分查找：对于已排序的数组，可以使用二分查找算法进行查找和计数。

#include <algorithm>
int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

//查找值为5的元素并计数
int count = std::upper_bound(array, array+10, 5) - std::lower_bound(array, array+10, 5);

if(count > 0) {
    cout << "数组中包含值为5的元素，共" << count << "个" << endl;
} else {
    cout << "数组中不包含值为5的元素" << endl;
}

//判断值为5的元素是否存在
bool exists = std::binary_search(array, array+10, 5);

if(exists) {
    cout << "数组中包含值为5的元素" << endl;
} else {
    cout << "数组中不包含值为5的元素" << endl;
}

4.标记查找:

#include <iostream>
using namespace std;

int main() {
    int m, n, a;
    cin >> m >> n >> a;
    bool found = false;  // 用于记录是否找到合适的解

    for (int i = 0; i <= a/m; i++) {
        for (int j = 0; j <= a/n; j++) {
            if (i*m + j*n == a) {
                found = true;
                break;
            }
        }
        if (found) {
            break;
        }
    }
    
    if (found) {
        cout << "Yes";
    } else {
        cout << "No";
    }

    return 0;
}

found 是一个布尔变量，用于记录是否找到满足条件的解。在代码中，如果存在一组非负整数 i 和 j，使得 im + jn 等于 a，那么 found 被设置为 true，否则为 false。通过检查 found 的值，我们可以确定是否找到了符合条件的解。

在代码的输出部分，根据 found 的值来输出结果。如果 found 为 true，则输出 “Yes”，表示找到了一组解；如果 found 为 false，则输出 “No”，表示未找到满足条件的解。

修正后的代码使用 found 变量来判断是否找到解，以避免重复输出结果。

当 found 变量被设置为 true 时，表示找到了一组满足条件的解。具体来说，在代码中，当内层循环找到满足条件的解后，会将 found 设置为 true。然后通过 break 关键字跳出内层循环和外层循环，不再进行后续的迭代。

在输出部分，根据 found 的值来确定输出的结果。如果 found 为 true，则输出 “Yes”，表示找到了一组解；如果 found 为 false，则输出 “No”，表示未找到满足条件的解。

使用 found 的目的是避免重复输出结果。如果不使用 found，那么每次在内层循环中判断到不满足条件时都会输出 “No”，导致重复输出多个 “No”。而使用 found，只有在找到满足条件的解时才输出 “Yes”，否则输出一次 “No”，避免了重复输出。

因此，通过 found 变量的使用，我们可以控制程序的输出，确保只输出一次正确的结果。

字符类型元素查找

数学类型的查找容易理解那么怎么在字符串中查找元素呢?
我举个例子:
我们要在s中查找"klj"

在 C++ 中，我们可以使用标准库提供的字符串查找函数来判断一个字符串中是否包含另一个字符串。其中，std::string 类提供了 find() 函数来进行字符串的查找操作。

以下是一个示例代码，演示了如何在字符串中查找是否出现 “kji” 这个子串：

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, kji world!";
    std::string subStr = "kji";

    // 使用 find() 函数查找子串
    size_t found = str.find(subStr);

    if (found != std::string::npos) {
        std::cout << "子串 '" << subStr << "' 在字符串中出现了！" << std::endl;
    } else {
        std::cout << "子串 '" << subStr << "' 在字符串中未找到！" << std::endl;
    }

    return 0;
}

在上述代码中，我们定义了一个字符串 str，并指定要查找的子串为 “kji”。然后，使用 find() 函数在 str 中查找子串的位置，并将结果存储在变量 found 中。

如果 find() 函数找到了子串，则返回子串在字符串中的起始位置（下标），即大于等于 0 的整数值；如果未找到子串，则返回 std::string::npos，它是一个特殊的静态成员常量，表示未找到。

根据 found 的值，我们可以判断子串是否在字符串中出现，并进行相应的处理。

运行上述代码，将输出：

子串 'kji' 在字符串中出现了！

如果将 subStr 改为其他字符串，如 “xyz”，则输出将是：

子串 'xyz' 在字符串中未找到！

这样，你就可以通过 find() 函数来判断一个字符串中是否包含指定的子串。

我们用find查找元素那么我们该怎么计数呢?
再举个例子:

要查找一个字符串中某个子串出现的次数，我们可以使用循环结合 find() 函数来实现。每次找到子串后，将计数器加一，并继续在剩余的字符串中查找，直到整个字符串被搜索完毕。

以下是一个示例代码，演示了如何统计字符串中某个子串出现的次数：

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, kji world! kji is kji.";
    std::string subStr = "kji";

    size_t found = str.find(subStr);
    int count = 0;

    while (found != std::string::npos) {
        count++;
        found = str.find(subStr, found + subStr.length());
    }

    std::cout << "子串 '" << subStr << "' 在字符串中出现了 " << count << " 次。" << std::endl;

    return 0;
}

在上述代码中，我们使用循环结构来重复执行以下操作：

1. 使用 find() 函数查找子串的位置，并将结果存储在变量 found 中。
2. 如果找到了子串，则将计数器 count 加一。
3. 继续在剩余的字符串中查找子串，从上一次找到的位置之后开始搜索。

当 find() 函数返回 std::string::npos 时，表示已经搜索完整个字符串，没有找到更多的子串。

最后，输出计数器 count 的值，即子串在字符串中出现的次数。

运行上述代码，将输出：

子串 'kji' 在字符串中出现了 3 次。

这样，我们就可以通过循环和 find() 函数来统计一个字符串中某个子串出现的次数。