如果“移动”操作相当昂贵，而“比较”操作很便宜，并且无论如何都需要将整个集合移动到一个缓冲区中，在那里搜索速度比原始存储快得多。。。只需将排序整合到强制移动中即可。

我发现，将分拣过程整合到晾衣架中，这一过程变得轻而易举。无论如何，我需要拿起每一只袜子，然后把它挂起来（移动），把它挂在绳子上的某个特定位置几乎不需要任何费用。现在，为了不强制搜索整个缓冲区（字符串），我选择按颜色/阴影放置袜子。左边更黑，右边更亮，前面更鲜艳。现在，在我挂上每一只袜子之前，我先看看它的“右边附近”是否已经有一只匹配的袜子——这限制了“扫描”其他2-3只袜子——如果有，我就把另一只挂在旁边。然后，我把它们成对地卷起来，然后在干的时候把它们从绳子上取下来。

现在，这似乎与顶级答案所建议的“按颜色形成桩”没有什么不同，但首先，通过不选择离散桩而是选择范围，我没有问题将“紫色”分类为“红色”还是“蓝色”桩；它只是介于两者之间。然后通过集成两个操作（挂起晾干和分拣），挂起时的分拣开销大约是单独分拣的10%。

我提出的解决方案假设所有袜子在细节上都是相同的，除了颜色。如果袜子之间有更多的细节需要延迟，这些细节可以用来定义不同类型的袜子，而不是我的例子中的颜色。。

假设我们有一堆袜子，袜子可以有三种颜色：蓝色、红色或绿色。

然后，我们可以为每种颜色创建一个并行工作程序；它有自己的列表来填充相应的颜色。

At time i:

Blue  read  Pile[i]    : If Blue  then Blue.Count++  ; B=TRUE  ; sync

Red   read  Pile[i+1]  : If Red   then Red.Count++   ; R=TRUE  ; sync

Green read  Pile [i+2] : If Green then Green.Count++ ; G=TRUE  ; sync

同步过程：

Sync i:

i++

If R is TRUE:
    i++
    If G is TRUE:
        i++

这需要初始化：

Init:

If Pile[0] != Blue:
    If      Pile[0] = Red   : Red.Count++
    Else if Pile[0] = Green : Green.Count++

If Pile[1] != Red:
    If Pile[0] = Green : Green.Count++

哪里

Best Case: B, R, G, B, R, G, .., B, R, G

Worst Case: B, B, B, .., B

Time(Worst-Case) = C * n ~ O(n)

Time(Best-Case) = C * (n/k) ~ O(n/k)

n: number of sock pairs
k: number of colors
C: sync overhead

我所做的就是拿起第一只袜子，把它放下（比如，放在洗衣碗的边缘）。然后我拿起另一只袜子，检查它是否与第一只袜子相同。如果是，我会把它们都去掉。如果不是，我把它放在第一只袜子旁边。然后我拿起第三只袜子，将其与前两只袜子进行比较（如果它们还在的话）。等

这种方法可以很容易地在阵列中实现，假设“移除”袜子是一个选项。实际上，你甚至不需要“脱掉”袜子。如果您不需要对袜子进行排序（见下文），那么您只需移动它们，就可以得到一个数组，该数组中所有袜子都成对排列。

假设袜子的唯一操作是比较相等，这个算法基本上仍然是n2算法，尽管我不知道平均情况（从未学会计算）。

当然，分类可以提高效率，尤其是在现实生活中，你可以很容易地将袜子“插入”在另外两个袜子之间。在计算中，树也可以做到这一点，但这是额外的空间。当然，我们又回到了NlogN（或者更多，如果有几只袜子按排序标准是相同的，但不是来自同一双）。

除此之外，我想不出什么，但这种方法在现实生活中似乎非常有效

一种有效的袜子配对算法

前提条件

堆里必须至少有一只袜子桌子必须足够大，以容纳N/2袜子（最坏情况），其中N是总数袜子。

算法

Try:

挑选第一只袜子把它放在桌子上选择下一只袜子，然后看看它（可能会把“不再有袜子”扔到袜子堆里）现在扫描桌子上的袜子（如果桌子上没有袜子，则抛出异常）有匹配的吗？a） 是=>从桌子上取下匹配的袜子b） no=>将袜子放在桌子上（可能会抛出“桌子不够大”异常）

除了：

桌子不够大：小心地将所有未配对的袜子混合在一起，然后继续操作//此操作将导致一个新的堆和一个空表桌子上没有袜子：扔（最后一只不受欢迎的袜子）堆里没有袜子：出口洗衣房

最后：

如果袜子堆里还有袜子：转到3

已知问题

如果或周围没有表，算法将进入无限循环桌子上没有足够的地方容纳至少一只袜子。

可能的改进

根据要分拣的袜子数量，吞吐量可能是通过整理桌子上的袜子来增加空间

为了使其工作，需要一个具有唯一每双袜子的价值。这样的属性很容易根据袜子的视觉财产合成。

按所述属性对桌上的袜子进行排序。让我们调用该属性“颜色”。将袜子排成一排，并将深色袜子放在右侧（即push_back（）），左侧（即。.push_front（））

对于大量的袜子，尤其是以前看不见的袜子，属性合成可能需要很长时间，因此吞吐量将明显下降。但是，这些属性可以保存在内存中并重用。

需要进行一些研究来评估这种可能性的效率改善出现以下问题：

上述袜子的最佳搭配数量是多少改善对于给定数量的袜子，之前需要多少次迭代吞吐量增加？a） 用于最后一次迭代b） 对于所有迭代

符合MCVE指南的PoC：

#include <iostream>
#include <vector>
#include <string>
#include <time.h>

using namespace std;

struct pileOfsocks {
    pileOfsocks(int pairCount = 42) :
        elemCount(pairCount<<1) {
        srand(time(NULL));
        socks.resize(elemCount);

        vector<int> used_colors;
        vector<int> used_indices;

        auto getOne = [](vector<int>& v, int c) {
            int r;
            do {
                r = rand() % c;
            } while (find(v.begin(), v.end(), r) != v.end());
            v.push_back(r);
            return r;
        };

        for (auto i = 0; i < pairCount; i++) {
            auto sock_color = getOne(used_colors, INT_MAX);
            socks[getOne(used_indices, elemCount)] = sock_color;
            socks[getOne(used_indices, elemCount)] = sock_color;
        }
    }

    void show(const string& prompt) {
        cout << prompt << ":" << endl;
        for (auto i = 0; i < socks.size(); i++){
            cout << socks[i] << " ";
        }
        cout << endl;
    }

    void pair() {
        for (auto i = 0; i < socks.size(); i++) {
            std::vector<int>::iterator it = find(unpaired_socks.begin(), unpaired_socks.end(), socks[i]);
            if (it != unpaired_socks.end()) {
                unpaired_socks.erase(it);
                paired_socks.push_back(socks[i]);
                paired_socks.push_back(socks[i]);
            }
            else
                unpaired_socks.push_back(socks[i]);
        }

        socks = paired_socks;
        paired_socks.clear();
    }

private:
    int elemCount;
    vector<int> socks;
    vector<int> unpaired_socks;
    vector<int> paired_socks;
};

int main() {
    pileOfsocks socks;

    socks.show("unpaired socks");
    socks.pair();
    socks.show("paired socks");

    system("pause");
    return 0;
}

真实世界方法：

尽快将袜子从未分类的袜子堆中取出，一次一个，然后放在前面。桩应布置得有一定的空间效率，所有袜子指向相同的方向；桩的数量受你容易到达的距离的限制。选择一堆袜子时，应尽快将袜子放在一堆看起来很像的袜子上；偶尔出现的I型（把袜子放在不属于它的袜子堆上）或II型（当有一堆类似的袜子时，把袜子放进自己的袜子堆里）错误是可以容忍的——最重要的考虑是速度。

一旦所有袜子都成了一堆，快速穿过多个袜子堆，创建成对的袜子，然后将它们取下（这些袜子朝抽屉方向）。如果袜子堆中有不匹配的袜子，请将它们重新堆到最好的位置（在尽可能快的限制范围内）。当处理完所有的多袜子堆后，将由于II类错误而未配对的剩余可配对袜子进行配对。哎呦，你完了——我有很多袜子，直到大部分都脏了才洗。另一个实际注意事项是：我将一双袜子的顶部翻转到另一双袜子上，利用它们的弹性财产，以便它们在被运送到抽屉和抽屉中时保持在一起。

如果你可以将一双袜子抽象为密钥本身，将另一双袜子作为值，那么我们可以使用哈希来发挥作用。

在你身后的地板上做两个假想的部分，一个给你，另一个给配偶。从袜子堆里取一只。现在，按照以下规则将袜子一只一只地放在地板上。确定袜子是你的还是她的，并查看地板上的相关部分。如果你能在地板上找到这双鞋，就把它捡起来，把它们系起来，或者把它们夹起来，或者在找到一双鞋后做任何你想做的事情，然后把它放在篮子里（把它从地板上取下来）。将其放在相关章节中。重复3次，直到所有袜子都从袜子堆上取下。

说明：

哈希和抽象

抽象是一个非常强大的概念，已用于改善用户体验（UX）。现实生活中与计算机交互的抽象示例包括：

用于在GUI（图形用户界面）中导航以访问地址的文件夹图标，而不是键入实际地址以导航到某个位置。GUI滑块用于控制不同级别的音量、文档滚动位置等。。

哈希或其他不到位的解决方案是不可选择的，因为我无法复制我的袜子（如果可以的话，这可能很好）。

我相信提问者正在考虑使用哈希，这样在放置袜子之前，应该知道袜子的位置。

这就是为什么我建议将放在地板上的一只袜子抽象为哈希键本身（因此不需要复制袜子）。

如何定义哈希键？

如果有不止一双类似的袜子，下面的密钥定义也适用。也就是说，假设有两双黑色男士袜子PairA和PairB，每双袜子都被命名为PairA-L、PairA-R、PairB-L和PairB-R。因此，PairA-L可以与PairB-R配对，但PairA-L和PairB-L不能配对。

假设任何袜子都可以通过以下方式唯一标识，

属性[性别]+属性[颜色]+属性（材质）+属性[类型1]+属性[类别2]+属性[左_右]

这是我们的第一个哈希函数。让我们对这个h1（G_C_M_T1_T2_LR）使用一个简短的符号。h1（x）不是我们的位置键。

消除Left_or_Right属性的另一个哈希函数是h2（G_C_M_T1_T2）。第二个函数h2（x）是我们的位置键！（你身后地板上的空间）。

要定位插槽，请使用h2（G_C_M_T1_T2）。一旦找到了槽，就使用h1（x）来检查它们的哈希值。如果它们不匹配，你就有一对。否则，把袜子扔到同一个槽里。

注意：由于我们在找到一个插槽时删除了一个插槽，因此可以安全地假设最多只有一个插槽具有唯一的h2（x）或h1（x）值。

如果我们每只袜子正好有一对匹配的袜子，那么使用h2（x）来查找位置，如果没有袜子，则需要进行检查，因为可以安全地假设它们是一对。

为什么把袜子放在地板上很重要

让我们考虑一个场景，袜子堆在一起（最坏的情况）。这意味着我们别无选择，只能进行线性搜索来找到一对。

将它们铺在地板上可以提高可见度，从而提高发现匹配袜子（匹配哈希键）的机会。当第三步把袜子放在地板上时，我们的大脑已经下意识地记录了位置。-因此，如果这个位置在我们的内存中可用，我们可以直接找到匹配的配对。-如果没有记住位置，不要担心，然后我们可以一直返回到线性搜索。

为什么从地板上取下这对鞋很重要？

短期人类记忆在需要记忆的项目较少时效果最好。因此，增加了我们使用哈希来识别这对的概率。当使用线性搜索对时，它还将减少要搜索的项目的数量。

分析

情况1：最坏的情况是，Derpina无法记住或直接使用哈希技术在地板上发现袜子。Derp对地板上的物品进行线性搜索。这并不比遍历堆以找到对更糟。比较上限：O（n^2）。比较下限：（n/2）。（当Derpina每捡一只袜子都是上一只的时候）。案例2：德普记得他放在地板上的每一只袜子的位置，每只袜子正好有一双。比较上限：O（n/2）。比较下限：O（n/2）。

我说的是比较操作，从袜子堆里挑选袜子必然是n次操作。因此，实际的下限是n次迭代，n/2次比较。

加快进度

为了获得完美的分数，使Derp获得O（n/2）比较，我建议Derpina，

花更多时间穿袜子来熟悉它。是的，这意味着也要花更多时间穿着德普的袜子。玩记忆游戏，如在网格中找出对，可以提高短期记忆性能，这是非常有益的。

这是否等同于元素清晰度问题？

我建议的方法是用于解决元素区分问题的方法之一，将它们放在哈希表中并进行比较。

考虑到您的特殊情况，即只有一个精确的对，它已经变得非常等价于元素区别问题。因为我们甚至可以对袜子进行分类，并检查相邻袜子是否成对（EDP的另一种解决方案）。

然而，如果给定袜子可能存在不止一双，那么它就偏离了EDP。