需要关于改进我的代码：搜索算法的建议吗 我在C++方面很新，需要对此提出一些建议。 在这里，我编写了一段代码，用于测量任意整数x在数组中出现的次数，并输出所做的比较

然而，我已经读到，通过使用多路分支（“分而治之！”）技术，我可以使算法运行得更快

谁能给我指出正确的方向我该怎么做

以下是我使用的另一种方法的工作代码：

#include <iostream>
#include <cstdlib>
#include <vector>

using namespace std;

vector <int> integers;
int function(int vectorsize, int count);
int x;
double input;

int main()
{
cout<<"Enter 20 integers"<<endl;
cout<<"Type 0.5 to end"<<endl;

while(true)
{
cin>>input;

if (input == 0.5)
break;

integers.push_back(input);
}

cout<<"Enter the integer x"<<endl;
cin>>x;

function((integers.size()-1),0);

system("pause");

}

int function(int vectorsize, int count)
{
    if(vectorsize<0) //termination condition
{
    cout<<"The number of times"<< x <<"appears is "<<count<<endl;
    return 0;
}    

if (integers[vectorsize] > x)
{
    cout<< integers[vectorsize] << " > " << x <<endl;
}

if (integers[vectorsize] < x)
{
    cout<< integers[vectorsize] << " < " << x <<endl;
}
if (integers[vectorsize] == x)
{
    cout<< integers[vectorsize] << " = " << x <<endl;

    count = count+1;
}

return (function(vectorsize-1,count));
}

#包括
#包括
#包括
使用名称空间std；
向量整数；
int函数（int vectorsize，int count）；
int x；
双输入；
int main（）
{
cout如果数组是未排序的，只需使用单个循环将每个元素与
x
进行比较。除非您忘记告诉我们什么，否则我认为没有必要进行更复杂的操作

如果对数组进行排序，则有一些算法（例如二进制搜索）具有更好的渐进复杂性。但是，对于20个元素的数组，简单的线性搜索仍然是首选策略。
如果您的数组是已排序的数组，则可以使用分而治之的策略：

分治算法只有在您可以使用它消除一些工作，或者如果您可以跨多个计算单元并行化被分割的工作部分时才是有益的。在您的情况下，第一个选项可以用于已排序的数据集，其他答案可能已经解决了这个问题

对于第二种解决方案，算法名为map reduce，它将数据集拆分为几个子集，将子集分配给尽可能多的线程或进程，并收集结果以“编译”它们（术语实际上是“reduce”）这是一个有意义的结果。在您的设置中，这意味着每个线程将扫描其自身的数组切片以计数项目，并将其结果返回给“reduce”线程，该线程将它们相加以返回最终结果。不过，此解决方案仅适用于大型数据集

在MapReduce和C++上有一些问题，但是我会在这里给你一个示例实现：
#include <utility>
#include <thread>
#include <boost/barrier>

constexpr int MAP_COUNT = 4;

int mresults[MAP_COUNT];

boost::barrier endmap(MAP_COUNT + 1);

void mfunction(int start, int end, int rank ){
    int count = 0;
    for (int i= start; i < end; i++)
        if ( integers[i] == x) count++;
    mresult[rank] = count;
    endmap.wait();
}

int rfunction(){
    int count = 0;
    for (int i : mresults) {
        count += i;
    }
    return count;
}

int mapreduce(){
    vector<thread &> mthreads;
    int range = integers.size() / MAP_COUNT;
    for (int i = 0; i < MAP_COUNT; i++ )
        mthreads.push_back(thread(bind(mfunction, i * range, (i+1) * range, i)));
    endmap.wait();
    return rfunction();
}

#包括
#包括
#包括
constexpr int MAP_COUNT=4；
int mresults[映射计数]；
屏障端映射（映射计数+1）；
void mfunction（int start、int end、int rank）{
整数计数=0；
for（int i=start；i

填充
整数
向量后，调用上面定义的
mapreduce
函数，该函数将返回预期结果。如您所见，实现非常专业化：


map和reduce函数针对您的问题
用于映射的线程数是静态的
我遵循你的风格，使用全局变量
为了方便起见，我使用了
boost:：barrier
进行同步

然而，这应该让您了解算法，以及如何将其应用于类似问题

警告：代码未经测试。
多路分支（“分而治之！”）技术？？？我在想一些类似的事情：我明白了。我只是想做一些不同于线性搜索的事情。我会继续阅读二进制搜索。Thanks@CandyMan如果你只是在做一个学习练习，那么我建议你选择一个不同的问题，因为你描述的问题不适合分而治之（这没有什么好处。）@CandyMan你链接到的维基百科文章给出了你可以尝试解决的问题的很好的例子（例如排序）。一般来说，链接到另一个问题最好作为评论，而不是答案。