Question

我到处都读到了分类和征服排序算法，如Merge-Sort和Quicksort，而不是递归直到只留下一个元素，最好转移到Insertion-Sort时达到某个阈值，比如30个元素。这很好，但为什么只有Insertion-Sort？为什么不Bubble-Sort或Selection-Sort，两者的性能相似O(N^2)？只有当许多元素被预先排序时，Insertion-Sort才会派上用场（尽管这个优势也应该带有Bubble-Sort），但除此之外，为什么它应该比其他两个更有效？

其次，在this link，在第二个答案及其附带的评论中，它表示O(N log N)与O(N^2)相比，某个N表现不佳。怎么会？ N^2的效果应该始终低于N log N，因为N > log N对所有N＆gt; = 2，对吧？

Answer 1

如果你击中Quidsort的每一个分支都达到了门槛，你的数据就像这样：

[the least 30-ish elements, not in order] [the next 30-ish ] ... [last 30-ish]

插入排序具有相当令人满意的属性，您可以在整个数组上只调用一次，并且它执行的基本相同，如果您为每个30的块调用它一次。所以不要在循环中调用它，您可以选择最后调用它。这可能不是更快，特别是因为它将整个数据通过缓存拉出额外的时间，但是根据代码的结构方式，这可能很方便。

冒泡排序和选择排序都没有这个属性，所以我认为答案可能很简单就是“方便”。如果有人怀疑选择排序可能会更好，那么举证责任在于他们“证明”它更快。

请注意，使用插入排序也有一个缺点 - 如果你这样做并且你的分区代码中有一个错误，那么它不会丢失任何元素，只是错误地对它们进行分区，你会从不注意。

编辑：显然这个修改是由Sedgewick在1975年在QuickSort上写下他的博士。最近由Musser（Introsort的发明者）进行了分析。参考https://en.wikipedia.org/wiki/Introsort

Musser还考虑了对Sedgewick缓存的影响延迟小排序，其中小范围在一个单独的末尾排序传递插入排序。他报告说它的数量可以增加一倍缓存未命中，但它的双端队列性能是显着更好，并应保留模板库，在部分因为其他情况下的收益立即进行排序不是很好。

无论如何，我不认为一般的建议是“无论你做什么，不要使用选择排序”。建议是，“插入排序将Quicksort输入到令人惊讶的非小尺寸”，当你实现Quicksort时，这很容易向自己证明。如果你想出另一种在同一个小阵列上明显优于插入排序的那种，那些学术资源都没有告诉你不要使用它。我认为令人惊讶的是，建议一直是插入排序，而不是每个消息来源选择自己喜欢的（介绍性教师有一个坦率的令人惊讶的喜欢冒泡 - 我不介意，如果我从来没有再次听到它）。插入排序通常被认为是小数据的“正确答案”。问题不在于它是否应该“快速”，而是它是否真的存在，而且我从未特别注意到任何消除这一想法的基准。

寻找此类数据的一个地方是Timsort的开发和采用。我很确定Tim Peters选择插入是出于某种原因：他没有提供一般建议，他正在优化图书馆以供实际使用。

Answer 2

插入排序在实践中比至少冒泡更快。它们的渐态运行时间是相同的，但插入排序具有更好的常量（每次迭代的操作更少/更便宜）。最值得注意的是，它只需要线性数量的元素对交换，并且在每个内部循环中，它执行每个 n / 2元素和一个“固定”元素之间的比较，这些元素可以存储在一个元素中。注册（冒泡排序必须从内存中读取值）。即插入排序在内循环中的工作量少于冒泡排序。
答案声称10000 n lg n ＆gt; 10 n ²表示“合理” n 。这最多可达14000个元素。

Answer 3

我很惊讶没有人提到这样一个简单的事实：对于＆＃34;几乎＆＃34;插入排序的速度要快得多。排序数据。这就是它被使用的原因。

Answer 4

这是经验证明插入排序比冒泡排序更快（对于30个元素，在我的机器上，附加的实现，使用java ...）。

我运行了附加代码，发现冒泡排序的平均运行时间为6338.515 ns，而插入时则为3601.0

我使用wilcoxon signed test来检查这是一个错误的概率，它们实际上应该是相同的 - 但是结果低于数值误差的范围（并且实际上是P_VALUE~ = 0）

private static void swap(int[] arr, int i, int j) { 
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

public static void insertionSort(int[] arr) { 
    for (int i = 1; i < arr.length; i++) {
        int j = i;
        while (j > 0 && arr[j-1] > arr[j]) { 
            swap(arr, j, j-1);
            j--;
        }
    }
}
public static void bubbleSort(int[] arr) { 
    for (int i = 0 ; i < arr.length; i++) { 
        boolean bool = false;
        for (int j = 0; j < arr.length - i ; j++) { 
            if (j + 1 < arr.length && arr[j] > arr[j+1]) {
                bool = true;
                swap(arr,j,j+1);
            }
        }
        if (!bool) break;
    }
}

public static void main(String... args) throws Exception {
    Random r = new Random(1);
    int SIZE = 30;
    int N = 1000;
    int[] arr = new int[SIZE];
    int[] millisBubble = new int[N];
    int[] millisInsertion = new int[N];
    System.out.println("start");
    //warm up:
    for (int t = 0; t < 100; t++) { 
        insertionSort(arr);
    }
    for (int t = 0; t < N; t++) { 
        arr = generateRandom(r, SIZE);
        int[] tempArr = Arrays.copyOf(arr, arr.length);

        long start = System.nanoTime();
        insertionSort(tempArr);
        millisInsertion[t] = (int)(System.nanoTime()-start);

        tempArr = Arrays.copyOf(arr, arr.length);

        start = System.nanoTime();
        bubbleSort(tempArr);
        millisBubble[t] = (int)(System.nanoTime()-start);
    }
    int sum1 = 0;
    for (int x : millisBubble) {
        System.out.println(x);
        sum1 += x;
    }
    System.out.println("end of bubble. AVG = " + ((double)sum1)/millisBubble.length);
    int sum2 = 0;
    for (int x : millisInsertion) {
        System.out.println(x);
        sum2 += x;
    }
    System.out.println("end of insertion. AVG = " + ((double)sum2)/millisInsertion.length);
    System.out.println("bubble took " + ((double)sum1)/millisBubble.length + " while insertion took " + ((double)sum2)/millisBubble.length);
}

private static int[] generateRandom(Random r, int size) {
    int[] arr = new int[size];
    for (int i = 0 ; i < size; i++) 
        arr[i] = r.nextInt(size);
    return arr;
}

修改
（1）优化冒泡排序（上面更新）将冒泡的总时间减少到：6043.806不足以做出重大改变。 Wilcoxon测试仍然是确定的：插入排序更快。

（2）我还添加了一个选择排序测试（附加代码）并将其与插入进行比较。结果是：选择花了4748.35，而插入花了3540.114。
wilcoxon的P_VALUE仍低于数值误差范围（有效〜= 0）

用于选择排序的代码：

public static void selectionSort(int[] arr) { for (int i = 0; i < arr.length ; i++) { int min = arr[i]; int minElm = i; for (int j = i+1; j < arr.length ; j++) { if (arr[j] < min) { min = arr[j]; minElm = j; } } swap(arr,i,minElm); } }

Answer 5

首先更容易：为什么插入排序超过选择排序？因为插入排序在 O（n）中是为了获得最佳输入序列，即序列是否已经排序。选择排序始终为 O（n ^ 2）。

为什么插入排序过冒泡排序？对于已排序的输入序列，两者都只需要一次传递，但插入排序会更好地降级。更具体地说，插入排序通常比泡泡排序的反转次数少。 Source这可以解释，因为冒泡排序总是遍历传递i中的Ni元素，而插入排序更像“查找”，并且只需要平均迭代（Ni）/ 2元素（在传递Ni-1中）找到插入位置。因此，插入排序预计平均比插入排序快两倍。

Answer 6

编辑：正如IVlad在评论中指出的那样，选择排序只对任何数据集进行n次交换（因此只有3n次写入），因此插入排序不太可能因为交换更少 - 但它可能会进行更少的比较。下面的推理更适合与冒泡排序进行比较，冒泡排序会进行相似数量的比较，但平均会进行更多交换（因此会有更多写入）。

插入排序往往比其他O（n ^ 2）算法（如冒泡排序和选择排序）更快的原因之一是因为在后面的算法中，每个数据移动都需要交换，如果交换的另一端需要稍后再次交换，则可以是所需内存副本的3倍。

使用插入排序OTOH，如果要插入的下一个元素不是最大元素，则可以将其保存到临时位置，并且所有下层元素通过从右侧开始并使用单个数据副本向前分流（即没有互换）。这为原始元素打开了一个空白。

不使用交换的插入排序整数的C代码：

void insertion_sort(int *v, int n) {
    int i = 1;
    while (i < n) {
        int temp = v[i];         // Save the current element here
        int j = i;

        // Shunt everything forwards
        while (j > 0 && v[j - 1] > temp) {
            v[j] = v[j - 1];     // Look ma, no swaps!  :)
            --j;
        }

        v[j] = temp;
        ++i;
    }
}

为什么在合并排序中的阈值交叉之后应使用插入排序

6 个答案: