Question

我正在编写一个自动完成程序，该程序会在给定字典文件和输入文件的情况下找到与一个字母或一组字符匹配的所有内容。我刚刚完成了一个通过迭代搜索实现二进制搜索的版本，并认为我可以提高程序的整体性能。

事实上，二进制搜索比迭代搜索差不多 9倍。是什么赋予了？我认为通过迭代使用二进制搜索来提高性能。

运行时间（bin搜索左侧）[Larger]： testing the time of each version

以下是每个版本的重要部分，可以使用cmake在my github构建并运行完整代码。

二进制搜索功能（在给定输入循环时调用）

bool search(std::vector<std::string>& dict, std::string in,
        std::queue<std::string>& out)
{
    //tick makes sure the loop found at least one thing. if not then break the function
    bool tick = false;  
    bool running = true;
    while(running) {
        //for each element in the input vector
        //find all possible word matches and push onto the queue
        int first=0, last= dict.size() -1;
        while(first <= last)
        {
            tick = false;
            int middle = (first+last)/2;
            std::string sub = (dict.at(middle)).substr(0,in.length());
            int comp = in.compare(sub);
            //if comp returns 0(found word matching case)
            if(comp == 0) {
                tick = true;
                out.push(dict.at(middle));
                dict.erase(dict.begin() + middle);      
            }
            //if not, take top half
            else if (comp > 0)
                first = middle + 1;
            //else go with the lower half
            else
                last = middle - 1;
        }
        if(tick==false)
            running = false;
    }
    return true;
}

迭代搜索（包含在主循环中）：

for(int k = 0; k < input.size(); ++k) {
        int len = (input.at(k)).length();
        // truth false variable to end out while loop
        bool found = false;
        // create an iterator pointing to the first element of the dictionary
        vecIter i = dictionary.begin();
        // this while loop is not complete, a condition needs to be made
        while(!found && i != dictionary.end()) {
            // take a substring the dictionary word(the length is dependent on
            // the input value) and compare
            if( (*i).substr(0,len) == input.at(k) ) {
                // so a word is found! push onto the queue
                matchingCase.push(*i);
            }
            // move iterator to next element of data
            ++i;    
        }

    }

示例输入文件：

z
be
int
nor
tes
terr
on

Answer 1

不是擦除向量中间的元素（这是非常昂贵的），然后开始搜索，只需比较找到的项目之前和之后的元素（因为它们应该彼此相邻），直到找到所有匹配的项目。

或者使用std::equal_range，就是这样。

Answer 2

这将是罪魁祸首：

dict.erase(dict.begin() + middle);

您反复从字典中删除项目以天真地使用二进制搜索来查找所有有效的前缀。这增加了巨大的复杂性，并且是不必要的。

相反，一旦找到匹配项，请向后退，直到找到第一个匹配项，然后再向前迈步，将所有匹配项添加到队列中。请记住，因为您的字典已排序且您只使用前缀，所有有效匹配将连续出现。

Answer 3

dict.erase操作在dict的大小是线性的：它将整个数组从中间复制到最后到数组的开头。这使得“二分搜索”算法在dict的长度上可能是二次的，具有O（N ^ 2）昂贵的存储器复制操作。

为什么我的二进制搜索与迭代相比如此疯狂？

3 个答案: