Sorting 高效分拣？

一段时间以来我一直在寻找这个问题的答案。。。“对一百万个32位整数排序最有效的方法是什么？”

我觉得快速分拣是最有效的分拣方式。。平均运行时间为O（n*logn）。（最坏情况为O（n²））

但是一些搜索结果表明，基数排序/合并排序对于排序百万个整数是有效的

---

有指针吗？

如果您有足够的空间，也许可以尝试桶排序(http://en.wikipedia.org/wiki/Bucket_sort). 它效率更高，但需要额外的内存来存储数据。

如果您有足够的空间，也许可以尝试bucket sort(http://en.wikipedia.org/wiki/Bucket_sort). 它效率更高，但需要额外的内存来存储数据。

Mergesort被保证为O（n lg n），但比快速排序具有更高的内存占用

Quicksort通常比mergesort运行得更快，但在~某些~情况下，它可能会降低到二次运行时间

基数排序是O（n*r），其中r是数字的长度

要确定基数是否优于您选择的lg-n方法，请执行以下操作：

n * r < n * lg (n)
divide by n on both sides
r < lg(n)

We know r is 32 bits

32 < lg(n)

for both sides, take 2^x

2^32 < 2^(lg(n)

2^32 < n

n*r

因此，如果n小于2^32（40亿），则使用lg-n算法

---

就我个人而言，我会使用快速排序，如果必须的话，会将其洗牌，以防止其降级。

Mergesort被保证为O（n lg n），但比快速排序具有更高的内存占用

Quicksort通常比mergesort运行得更快，但在~某些~情况下，它可能会降低到二次运行时间

基数排序是O（n*r），其中r是数字的长度

要确定基数是否优于您选择的lg-n方法，请执行以下操作：

n * r < n * lg (n)
divide by n on both sides
r < lg(n)

We know r is 32 bits

32 < lg(n)

for both sides, take 2^x

2^32 < 2^(lg(n)

2^32 < n

n*r

因此，如果n小于2^32（40亿），则使用lg-n算法

---

就我个人而言，我会使用快速排序，如果有必要，我会将其洗牌，以防止其降级。

对于大数字，基数更好，尤其是当您知道数字的范围时

计算修复：

基数是O（kN）其中k是最大数字中的位数。（实际上是d*k*N其中d是基数，将使用的存储桶数…字母=26，十进制=10，二进制=2）

Maxint=4294967296
32位：k=32/对数（d）

以10为基数：

d*k*n = 10*10*n < nlogn .... 100 < logn ... n > 2^100  

d*k*n = 10*4*n < nlogn .... 40 < logn ... n > 2^40 

d*k*n=10*10*n2^100

基数2：

d*k*n = 2*32*n < nlogn .... 64 < logn ... n > 2^64

d*k*n = 2*10*n < nlogn .... 20 < logn ... n > 2^20

d*k*n=2*32*n2^64

因此，对于32位数字，如果您有超过2^64个数字，则n*k*n优于nlogn

但是，如果您知道范围将达到1024，而不是MAXINT，例如：

MaxNumber=1024

以10为基数：

d*k*n = 10*10*n < nlogn .... 100 < logn ... n > 2^100  

d*k*n = 10*4*n < nlogn .... 40 < logn ... n > 2^40 

d*k*n=10*4*n2^40

基数2：

d*k*n = 2*32*n < nlogn .... 64 < logn ... n > 2^64

d*k*n = 2*10*n < nlogn .... 20 < logn ... n > 2^20

d*k*n=2*10*n2^20

因此，对于1024以内的数字，如果您有超过2^20个数字，则n*k*n优于nlogn

因为大O符号会丢弃 平面上的乘法常数 运行时间，而忽略了效率 对于低输入大小，它不会 始终显示中最快的算法 实际大小数据的实践或分析 设置，但方法仍然非常简单 用于比较 各种算法的可扩展性 输入大小变大

---

对于大的数字，基数更好，特别是当你知道数字的范围时

计算修复：

基数是O（kN）其中k是最大数字中的位数。（实际上是d*k*N其中d是基数，将使用的存储桶数…字母=26，十进制=10，二进制=2）

Maxint=4294967296
32位：k=32/对数（d）

以10为基数：

d*k*n = 10*10*n < nlogn .... 100 < logn ... n > 2^100  

d*k*n = 10*4*n < nlogn .... 40 < logn ... n > 2^40 

d*k*n=10*10*n2^100

基数2：

d*k*n = 2*32*n < nlogn .... 64 < logn ... n > 2^64

d*k*n = 2*10*n < nlogn .... 20 < logn ... n > 2^20

d*k*n=2*32*n2^64

因此，对于32位数字，如果您有超过2^64个数字，则n*k*n优于nlogn

但是，如果您知道范围将达到1024，而不是MAXINT，例如：

MaxNumber=1024

以10为基数：

d*k*n = 10*10*n < nlogn .... 100 < logn ... n > 2^100  

d*k*n = 10*4*n < nlogn .... 40 < logn ... n > 2^40 

d*k*n=10*4*n2^40

基数2：

d*k*n = 2*32*n < nlogn .... 64 < logn ... n > 2^64

d*k*n = 2*10*n < nlogn .... 20 < logn ... n > 2^20

d*k*n=2*10*n2^20

因此，对于1024以内的数字，如果您有超过2^20个数字，则n*k*n优于nlogn

因为大O符号会丢弃 平面上的乘法常数 运行时间，而忽略了效率 对于低输入大小，它不会 始终显示中最快的算法 实际大小数据的实践或分析 设置，但方法仍然非常简单 用于比较 各种算法的可扩展性 输入大小变大

---

在最坏的情况下，合并排序是O（n logn），所以它在大多数情况下都比快速排序好。基数排序iirc只有在每个被排序的东西都是相同长度时才真正有用。它的计时单位是O（K*n），即（项目长度）*（项目数）。我想我从来都不需要使用基数排序。

合并排序是O（n logn）在最坏的情况下，它在大多数情况下都比快速排序好。基数排序，iirc，只有在每个被排序的东西都是相同长度的情况下才真正有用。它以O（K*N）计时，即（项目长度）*（项目数）。我想我从来都不需要使用基数排序。

这里有许多未回答的问题