是什么减慢了对键对的排序速度

实现接受答案后的计时

将 lambda 定义从：

[] (String_pair x, String_pair y) {
    return x.first < y.first;
}

自：

[] (const String_pair &x, const String_pair &y) {
    return x.first < y.first;
}

将分拣时间缩短至 0.23 秒。这仍然比使用 sort 稍慢，这并不奇怪。大多数具有相同键的字符串可能在第一个字符上已经不同，并且向量中只有 1/8 的元素具有多次出现的键。

最初的问题

来自"编程珍珠"的玩具问题，在英语中查找字谜。这不是家庭作业，但您可以像对待一样对待这个问题。为了解决这个问题，我实现了教科书解决方案：

1. 计算字典中每个单词的签名(单词本身，按字符排序(
2. 按签名排序(所有单词都在 {签名， 单词} 对中(
3. 输出具有相同签名且长度大于 1 的运行。

这当然是微不足道的，为了让它更有趣一点，我使用了ICU库(在Roland Illig的帮助下(，这样程序就不会被非ASCII字符阻塞，并且可以在芬兰语中找到字谜。

以下是完整的程序。诚然，它有点长，但要用更少的代码生成真实的测试输入和输出并不容易。

$ cat find-anagrams.cpp
#include <iostream>
#include <algorithm>
#include <vector>
#include "unicode/ustream.h"
#include "unicode/unistr.h"
#include "unicode/schriter.h"
#include <chrono>
int main()
{
    using String = icu::UnicodeString;
    using String_pair = std::pair<String, String>;
    using namespace std::chrono;
    auto start = steady_clock::now();
    // sign
    std::vector<String_pair> ws;
    String w;
    while (std::cin >> w) {
        String k{w};
        auto n = k.length();
        UChar *begin = k.getBuffer(n);
        if (!begin) return 1;
        std::stable_sort(begin, begin + n);
        k.releaseBuffer(n);
        ws.emplace_back(k, w);
    }
    auto sign_done = steady_clock::now();
    // sort
    std::stable_sort(ws.begin(), ws.end(),
            [] (String_pair x, String_pair y) {
                return x.first < y.first;
            });
    auto sort_done = steady_clock::now();
    // squash
    auto begin = ws.cbegin();
    while (begin != ws.cend()) {
        auto sig = begin->first;
        auto run_end = std::partition_point(begin, ws.cend(),
                [&sig] (String_pair x) {
                    return sig == x.first;
                });
        if ((run_end - begin) > 1) {
            std::cout << begin->second;
            ++begin;
            while (begin != run_end) {
                std::cout << ' ' << begin->second;
                ++begin;
            }
            std::cout << 'n';
        }
        begin = run_end;
    }
    auto squash_done = steady_clock::now();
    duration<double> time;
    time = duration_cast<duration<double>>(sign_done - start);
    std::cerr
        << "Read and calculate signatures:n"
        << 't' << time.count() << " secn";
    time = duration_cast<duration<double>>(sort_done - sign_done);
    std::cerr
        << "Sort by signatures:n"
        << 't' << time.count() << " secn";
    time = duration_cast<duration<double>>(squash_done - sort_done);
    std::cerr
        << "Squash and output:n"
        << 't' << time.count() << " secn";
    time = duration_cast<duration<double>>(squash_done - start);
    std::cerr
        << "Total:n"
        << 't' << time.count() << " secn";
    return 0;
}

这是我正在使用的编译器：

$ g++ -v
Using built-in specs.
COLLECT_GCC=g++
COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-pc-linux-gnu/6.1.1/lto-wrapper
Target: x86_64-pc-linux-gnu
Configured with: /build/gcc/src/gcc/configure --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://bugs.archlinux.org/ --enable-languages=c,c++,ada,fortran,go,lto,objc,obj-c++ --enable-shared --enable-threads=posix --enable-libmpx --with-system-zlib --with-isl --enable-__cxa_atexit --disable-libunwind-exceptions --enable-clocale=gnu --disable-libstdcxx-pch --disable-libssp --enable-gnu-unique-object --enable-linker-build-id --enable-lto --enable-plugin --enable-install-libiberty --with-linker-hash-style=gnu --enable-gnu-indirect-function --disable-multilib --disable-werror --enable-checking=release
Thread model: posix
gcc version 6.1.1 20160707 (GCC) 

这是我编译它的方式：

g++  --std=c++0x  -pedantic -Wall -O2 -std=c++14  -L/usr/lib -licui18n -licuuc -licudata   -licuio  find-anagrams.cpp -o cpp-find-anagrams

这就是我运行它的方式，还显示了时间：

./cpp-find-anagrams < clean-words | sort > cpp-result
Read and calculate signatures:
    0.328156 sec
Stable sort by signatures:
    0.512024 sec
Squash and output:
    0.189494 sec
Total:
    1.02967 sec

clean-words是/usr/share/dict/words中发现的单词，通过以下内容：

sed -n '/'"'"'s$/!p' | tr [:upper:] [:lower:] | sort --unique

换句话说，去掉带有撇号、所有大写字母和所有大写重复项的单词。

我们观察到，使用 std::stable_sort 和 lambda 进行排序花费的时间太长。相比之下，如果我对整对进行排序，大约需要一半的时间。更改，在上面的程序中：

    // sort
    std::stable_sort(ws.begin(), ws.end(),
            [] (String_pair x, String_pair y) {
                return x.first < y.first;
            });

自：

    // sort
    std::sort(ws.begin(), ws.end());

提供以下计时：

./cpp-find-anagrams < clean-words | sort > cpp-result
Read and calculate signatures:
    0.338751 sec
Sort pairs:
    0.216526 sec
Squash and output:
    0.168725 sec
Total:
    0.724002 sec

(0.51 秒至 0.22 秒(

当然，这两种排序给出的结果相同，因为输入文件中的单词已经排序。值得注意的是，这不是sort与stable_sort的问题。使用stable_sort(我知道这个输入是不必要的，但无论如何(，所以改为：

    // sort
    std::stable_sort(ws.begin(), ws.end());

仅对计时进行最小程度的更改：

./cpp-find-anagrams < clean-words | sort > cpp-result
Read and calculate signatures:
    0.334139 sec
Stable sort by signatures:
    0.264751 sec
Squash and output:
    0.180663 sec
Total:
    0.779552 sec

(0.22 秒至 0.26 秒(

在试图弄清楚发生了什么时，我在 SWI-Prolog 中实现了相同的算法，并注意到内置的 sort 和 keysort 谓词显示了预期的差异，即sort需要比keysort更长的时间。通过以下实现(再次，完整程序(：

$ cat find-anagrams.pl
:- use_module(library(apply_macros)).
:- use_module(library(pairs)).
main :-
    statistics(cputime, Start),
    read_words(Ws),
    sign_words(Ws, Signed),
    statistics(cputime, Sign_done),
    keysort(Signed, Sorted),
    statistics(cputime, Sort_done),
    squash(Sorted, Anagrams),
    maplist(anagrams_string, Anagrams, Str),
    atomics_to_string(Str, "n", Output),
    format(current_output, "~s~n", [Output]),
    statistics(cputime, Squash_done),
    format(user_error,
        "Read and calculate signatures:nt~f sec~nc
         Sort by signatures:nt~f sec~nc
         Squash and output:nt~f sec~nc
         Total:nt~f secn",
        [Sign_done - Start,
         Sort_done - Sign_done,
         Squash_done - Sort_done,
         Squash_done - Start]),
    halt.
main :- halt(1).
anagrams_string(Anagrams, Str) :-
    atomics_to_string(Anagrams, " ", Str).
read_words(Ws) :-
    read_string(current_input, _, Input),
    split_string(Input, "n", "", Ws).
sign_words(Ws, Signed) :-
    maplist(string_codes, Ws, Ws_codes),
    maplist(sort(0, @=<), Ws_codes, Ss_codes),
    maplist(string_codes, Ss, Ss_codes),
    pairs_keys_values(Signed, Ss, Ws).
squash(Sorted, Anagrams) :-
    group_pairs_by_key(Sorted, Grouped),
    groups_anagrams(Grouped, Anagrams).
groups_anagrams([], []).
groups_anagrams([_-Set|Rest], As) :-
    length(Set, N),
    (   N > 1
    ->  As = [Set|As0]
    ;   As = As0
    ),
    groups_anagrams(Rest, As0).

这是我正在使用的Prolog：

$ swipl -v
SWI-Prolog version 7.3.24 for x86_64-linux

我"编译"程序(为解释器创建一个"保存状态"(：

swipl -q -O --goal=main -o swi-find-anagrams -c find-anagrams.pl

并运行它：

./swi-find-anagrams < clean-words | sort > swi-result
Read and calculate signatures:
    0.928485 sec
Stable sort by signatures:
    0.174832 sec
Squash and output:
    0.183567 sec
Total:
    1.286884 sec

当我改变时

keysort(Signed, Sorted),

跟

sort(Signed, Sorted),

我得到以下增加的排序运行时间：

./swi-find-anagrams < clean-words | sort > swi-result
Read and calculate signatures:
    0.935780 sec
Sort pairs:
    0.269151 sec
Squash and output:
    0.187508 sec
Total:
    1.392440 sec

(0.17 至 0.27 秒(

排序的最终结果是相同的，但是，正如预期的那样，仅按键排序要快得多。

问题终于来了

我错过了什么？为什么少做事成本更高？

我知道我可以使用地图来实现相同的最终结果，但了解导致这种显着减速的原因仍然很有趣。