Sorting 整数列表的排序算法

我有一个大约200个整数的列表，它们的值在1到5之间

我想学习排序算法，并知道在哪里应用每种算法，因为目前我对所有我被告知的事情都使用冒泡排序，这是一种糟糕的方法

这种整数排序的最快排序算法是什么

编辑：事实证明，因为我知道数字是1到5，所以我可以使用桶排序（？）算法，如果我没有弄错的话——我肯定会弄错——这意味着对于值1的每个整数，我把它放在1组中，值2我把它放在2组中，等等，然后在最后连接这些组。这似乎是一种简单而有效的方法

然而，由于这（目前）对我来说是一个学习练习，我将取消1-5限制，尝试实现冒泡排序和合并排序，然后比较两者，看看哪一个更快

谢谢你的帮助

排序是一种O（n log n）方法，我认为它比快速排序好

你可以找到一些C代码。

排序是一种O（n log n），我认为它比快速排序更好

---

你可以找到一些C代码。

你可能不需要在这里排序，因为你只有5个可能的值。 您可以使用5个容器（或存储桶），在扫描整数列表时，将值放入正确的存储桶中。

---

最后，按顺序将桶连接在一起。

此处可能不需要排序，因为您只有5个可能的值。 您可以使用5个容器（或存储桶），在扫描整数列表时，将值放入正确的存储桶中。 最后，按顺序将铲斗连接在一起

。。。有人告诉我这是一种可怕的做事方式

首先，不要把你从互联网上随机听到的任何东西（包括我）当作福音

在某些情况下，冒泡排序是可以的，例如数据已经基本排序，或者项目数量相对较少（例如200）（a），或者语言中没有内置排序功能，并且您的截止日期很紧，缺乏性能会让客户感到烦恼，但缺乏功能会让您被解雇：-）

这种对冒泡排序的偏见类似于“一个函数只有一个退出点”和“无转到”规则。你应该理解它们背后的原因，这样你就知道什么时候可以安全地忽略这些规则

不管怎么说，这是一个恰当的问题。针对您的具体情况，一种有效的方法是只计算项目，然后输出它们，例如：

dim count[1..5] = {0, 0, 0, 0, 0};
for each item in list:
    count[item] = count[item] + 1
for val in 1..5:
    for quant in 1..count[val]:
        output val

这是一个O（n）时间和O（1）空间的解决方案，对于一个通用排序例程，你不会找到一个更有效的大O-只有在这种情况下才可能，因为你有关于数据的额外信息（限于值1到5）

如果您想检查所有不同的排序算法，则是一个有用的起点，包括主要算法及其属性

---

（a） 另外，以下代码（使用气泡排序的最坏情况数据）在CygWin下在功能不太强大的IBM T60（2GHz双核）笔记本电脑上运行时，平均完成时间为0.157秒（5个示例：0.150、0.125、0.192、0.199、0.115）

我不会用它来排序一百万个项目（每个人都知道冒泡排序的比例很低），但在大多数情况下，200个应该可以：

#include <stdio.h>

#define COUNT 200
int main (void) {
    int i, swapped, tmp, item[COUNT];

    // Set up worst case (reverse order) data.

    for (i = 0; i < COUNT; i++)
        item[i] = 200 - i;

    // Slightly optimised bubble sort.

    swapped = 1;
    while (swapped) {
        swapped = 0;
        for (i = 1; i < COUNT; i++) {
            if (item[i-1] > item[i]) {
                tmp = item[i-1];
                item[i-1] = item[i];
                item[i] = tmp;
                swapped = 1;
            }
        }
    }

    // for (i = 0; i < COUNT; i++)
    //     printf ("%d ", item[i]);
    // putchar ('\n');

    return 0;
}

#包括
#定义计数200
内部主（空）{
int i，交换，tmp，项目[计数]；
//设置最坏情况（逆序）数据。
对于（i=0；i第[i]项）{
tmp=项目[i-1]；
第[i-1]项=第[i]项；
第[i]项=tmp；
交换=1；
}
}
}
//对于（i=0；i

。。。有人告诉我这是一种可怕的做事方式

首先，不要把你从互联网上随机听到的任何东西（包括我）当作福音

在某些情况下，冒泡排序是可以的，例如数据已经基本排序，或者项目数量相对较少（例如200）（a），或者语言中没有内置排序功能，并且您的截止日期很紧，缺乏性能会让客户感到烦恼，但缺乏功能会让您被解雇：-）

这种对冒泡排序的偏见类似于“一个函数只有一个退出点”和“无转到”规则。你应该理解它们背后的原因，这样你就知道什么时候可以安全地忽略这些规则

不管怎么说，这是一个恰当的问题。针对您的具体情况，一种有效的方法是只计算项目，然后输出它们，例如：

dim count[1..5] = {0, 0, 0, 0, 0};
for each item in list:
    count[item] = count[item] + 1
for val in 1..5:
    for quant in 1..count[val]:
        output val

这是一个O（n）时间和O（1）空间的解决方案，对于一个通用排序例程，你不会找到一个更有效的大O-只有在这种情况下才可能，因为你有关于数据的额外信息（限于值1到5）

如果您想检查所有不同的排序算法，则是一个有用的起点，包括主要算法及其属性

---

（a） 另外，以下代码（使用气泡排序的最坏情况数据）在CygWin下在功能不太强大的IBM T60（2GHz双核）笔记本电脑上运行时，平均完成时间为0.157秒（5个示例：0.150、0.125、0.192、0.199、0.115）

我不会用它来排序一百万个项目（每个人都知道冒泡排序的比例很低），但在大多数情况下，200个应该可以：

#include <stdio.h>

#define COUNT 200
int main (void) {
    int i, swapped, tmp, item[COUNT];

    // Set up worst case (reverse order) data.

    for (i = 0; i < COUNT; i++)
        item[i] = 200 - i;

    // Slightly optimised bubble sort.

    swapped = 1;
    while (swapped) {
        swapped = 0;
        for (i = 1; i < COUNT; i++) {
            if (item[i-1] > item[i]) {
                tmp = item[i-1];
                item[i-1] = item[i];
                item[i] = tmp;
                swapped = 1;
            }
        }
    }

    // for (i = 0; i < COUNT; i++)
    //     printf ("%d ", item[i]);
    // putchar ('\n');

    return 0;
}

#包括
#定义计数200
内部主（空）{
int i，交换，tmp，项目[计数]；
//设置最坏情况（逆序）数据。
对于（i=0；i