快速排序 3 个值答案

【问题标题】：Quickly sort 3 values快速排序 3 个值
【发布时间】：2014-05-18 18:56:18
【问题描述】：

我有一个包含三个浮点值的数组，我想按升序对它们进行排序（尽管可能任何排序算法的顺序都可以轻松颠倒）。调用 std::sort 似乎有点矫枉过正：

float values[3] = {...};
std::sort(values, values + 3);

你可以这样做：

float sorted[3] = {min(values), values[0] + values[1] + values[2] -
    min(values) - max(values), max(values)};

但这看起来很丑陋。此外，数字的加减可能会改变中间排序元素的值。而且它不容易就地工作。也很有趣：

float sorted[3];
/*for(int i = 0; i < 3; ++ i) { // unroll
    sorted[(values[i] > values[0]) + (values[i] > values[1]) +
        (values[i] > values[2])] = values[i];
}*/ // this is broken, does not work if two or all values are equal
sorted[(values[0] > values[1]) + (values[0] > values[2])] = values[0];
sorted[(values[1] >= values[0]) + (values[1] > values[2])] = values[1];
sorted[(values[2] >= values[0]) + (values[2] >= values[1])] = values[2];

但这取决于如何将比较结果转换为整数（可能是比较+标志加载指令）。还取决于编译器如何优化每个元素与其自身的比较，如果您考虑特殊的浮点值，这并不容易。也不能就地工作。

#define cswap(a,b) do { if(a > b) { float tmp = a; a = b; b = tmp; } } while(0)
cswap(values[0], values[1]);
cswap(values[1], values[2]);
cswap(values[0], values[1]);

可能有一个排序网络，但我认为除了两个元素的幂之外，这不是排序的最佳选择。只有三个元素......似乎应该有一个非常简单的方法来做到这一点，但也许没有。

对三个数字进行排序的最小且同时快速的方法是什么？可读性在这里不是问题。

这有点类似于Fastest sort of fixed length 6 int array，但在这里我希望有一些简短但快速的代码，因为与任意数量的项目的排序循环相比，对 3 个值进行排序可能用更少的代码行编写。

结果：

在 Intel Core i7-2620M 和 Windows 7 上测量了 1000 亿个数字。Visual Studio 2008 发布，这些数字是使用 rand() 生成的，但减去了其中花费的时间。

std::sort method: 3.510 sec
min/max method: 2.964 sec
comparison insertion: 2.091 sec (the fixed version, 2.292 for the buggy one)
sort3() by Jarod42: 1.966 sec
sorting network: 1.903 sec

【问题讨论】：

为什么调用std::sort“矫枉过正”？第一个 sn-p 是最短的，也是迄今为止最清晰的，所以你已经有了“最小”的挂钩。如果您正在寻找性能，您能说明确切的性能要求吗？ StackOverflow 不是查询“聪明”代码的地方，请参阅other site。
第一个 sn-p 是最清晰+最快的，除非您可以对此处未给出的值做出假设。
当然使用std::sort 可能是“矫枉过正”，但你在做什么也很清楚。
好的，我明白了。它应该既简短又有效。 std::sort 简短易读，但如果我没记错的话，排序的一些实现使用合并排序，这将分配一些额外的内存。对于三个值，这似乎需要做很多工作。它应该简短而快速，可读性不是问题。
“最喜欢的最小/快速/聪明的方式”-“快速”（est）可能还可以，但不是“最喜欢”（基于意见），而不是“聪明”或“最小”（可能属于Code Golf，作为单独的问题）。虽然，“最快”似乎与链接的问题太相似了。

标签： c++ arrays algorithm sorting

【解决方案1】：

if (Value1 < Value2)
    {
        if (Value1 < Value3)
        {
            if (Value2 < Value3)
            {
                First = Value1;
                Second = Value2;
                Third = Value3;
            }
            else
            {
                First = Value1;
                Second = Value3;
                Third = Value2;
            }
        }
        else // Value3 < Value1
        {
            First = Value3;
            Second = Value1;
            Third = Value2;
        }
    }
    else // Value2 < Value1
    {
        if (Value2 < Value3)
        {
            if (Value1 < Value3)
            {
                First = Value2;
                Second = Value1;
                Third = Value3;
            }
            else
            {
                First = Value2;
                Second = Value3;
                Third = Value1;
            }
        }
        else //Value3 < Value2
        {
            First = Value3;
            Second = Value2;
            Third = Value1;
        }
    }

【讨论】：

【解决方案2】：

来自@Jarod42 的 sort3 是一种比“通用”算法（来自 Jim Mischel）更好的算法（这是网络算法），因为它可以在 a[0]

事实上，Jim Mischel 的算法就是冒泡排序算法。

【讨论】：

In fact Jim Mischel's algorithm is the bubble sort algorithm. 你能检查一下这个事实吗，至少可以参考冒泡排序的一个具体演示/实现/可视化？
确切地说是冒泡排序的展开版本en.m.wikipedia.org/wiki/Bubble_sort
第二个比较冒泡排序是什么？第二个Jim Mischel proposes是什么？

【解决方案3】：

一般算法是：

if (a[0] > a[1])
    swap(a[0], a[1]);
if (a[0] > a[2])
    swap(a[0], a[2]);
if (a[1] > a[2])
    swap(a[1], a[2]);

【讨论】：

谢谢。您可能会注意到这是一个排序网络，类似于问题中已经进行基准测试的网络（只有您的网络不那么混乱）。我想运行时会是一样的。

【解决方案4】：

如果我没有使用std::sort，我会使用：

template <typename T>
void sort3(T (&a)[3])
{
    if (a[0] < a[1]) {
        if (a[1] < a[2]) {
            return;
        } else if (a[0] < a[2]) {
            std::swap(a[1], a[2]);
        } else {
            T tmp = std::move(a[0]);
            a[0] = std::move(a[2]);
            a[2] = std::move(a[1]);
            a[1] = std::move(tmp);
        }
    } else {
        if (a[0] < a[2]) {
            std::swap(a[0], a[1]);
        } else if (a[2] < a[1]) {
            std::swap(a[0], a[2]);
        } else {
            T tmp = std::move(a[0]);
            a[0] = std::move(a[1]);
            a[1] = std::move(a[2]);
            a[2] = std::move(tmp);
        }
    }
}

【讨论】：

【解决方案5】：

只有 6 种可能的排列，所以你可以写一堆嵌套的条件来获得所有的可能性。参见，例如，here。另一方面，像insertion sort 这样简单但更通用的东西对于小型数组是有效的。插入排序也用作optimization for sorting smaller arrays in quicksort。所以你会期望它在std::sort中使用。

确实，我刚刚调试到std::sort，并在我的实现（VC++2012）中对较小的数组使用了插入排序。如果在编译时已知数组的大小为 3，那么可以肯定的是，生成的代码将是相当优化的。因此我会坚持使用std::sort，除非有非常充分的理由进行优化。

【讨论】：