【问题标题】:Sorting of Array to find first 20 smallest number [duplicate]对数组进行排序以找到前 20 个最小的数字 [重复]
【发布时间】:2011-12-06 03:14:29
【问题描述】:

可能重复:
Algorithm to find k smallest numbers in array of n items

如何在一个非常大的数组中找到前 20 个最小的元素?

【问题讨论】:

  • 你想要第一个元素还是最小的 20 个元素?你不能两者兼得
  • 可能更适合programmers.stackexchange.com,因为这似乎与平台无关?
  • @PirateKitten 平台不可知论者并不能免除自己成为算法的责任。程序员关注的是流程,而不是算法。
  • 啊,很公平,虽然有overlap,而且鉴于没有涉及来源,我认为这是一个有效的建议。

标签: arrays algorithm hash


【解决方案1】:

你有两个选择

  1. 对数组进行排序并拉出小端的 20 个元素(取决于您对数组进行排序的方向,对吗?)
  2. 保留数组元素的有序集合(由于数组的非唯一性可能不是集合)。添加数组中的前 20 个元素。每次在“好集合”中找到一个小于最高元素的元素时,将最高元素替换为这个新元素。

第二个可能看起来更慢,但它确实取决于数组的大小。您可以通过一次数组来完成,因此最好在一个 80 亿左右的数组上执行此操作。

编辑:第一个算法是O(n lg n)。第二种算法是O(k n),这里的 k 是 20(你想要前 20 个)。所以第二种算法在lg n > 20或n > 2^20或n > ~1 million时更快。因此,如果您的资产少于一百万,则最好进行分类。如果你有超过一百万,你最好制作外部列表并通过一次。

【讨论】:

  • 哇,我很好奇为什么这被否决了,因为它是列表中最详细、最正确的答案。
  • 当数组包含超过 100 万个元素时,选项 2 会更快,因为排序是 O(n lg n) 且 lg 1000000 = 20。关键限制可能更小,因为 n lg n 排序更复杂工作而不是更新 20 个元素的列表。
  • 能不能有一个过程,我们可以先散列那个数组,然后排序,最后找到前20个值,这样我们就不用对一个很大的数组进行排序了。
  • @avo 是的,完全正确。只是好奇,我的回答不是表明了吗? :-)
  • @Sumeet 起初看起来是这样,但后来你发现自己还在做一个排序。你可以尝试做一些减少列表的事情(比如占用数组的最小一半或其他东西),但它最终总是比选项 2 效率略低,因为它必须不断猜测截止点在哪里。跨度>
【解决方案2】:

如果数组真的很大,排序需要很长的时间和很大的空间。

你需要什么:

  • 将数组 A 的前 20 个元素复制到新数组 B 中。

  • B 类

  • 遍历数组 A 并检查每个元素是否小于 B[19]

  • 如果是=>添加到B,排序B,删除B的最后一个元素

【讨论】:

  • 使用排序数组会不必要地增加复杂性。使用具有O(k) 插入成本的链表会好得多,而不是使用O(k lg k) 的数组。
【解决方案3】:

不确定它是否是最佳的,但您可以尝试运行 20 次插入排序迭代。

【讨论】:

  • 该算法的复杂度当然是 20*n,其中 n 是数组的长度。
  • 这实际上是最佳的,具体取决于大小。它在大小为 21 的“大”数组上并不是那么理想。:-)
  • 比对整个事物进行排序要好,即使 2^20 事物适用。不知道这次我有什么办法摆脱它,虽然......
【解决方案4】:

看在上帝的份上,不要对整个数组进行排序。将大小为 20 的数组初始化为大数组的前 20 个元素。现在,逐步遍历大数组,替换小数组中比您当前正在考虑的大数组中的元素大的任何元素。这是 O(n);比任何基于比较的排序都要好,并且可能比线性排序(无论如何不能总是使用)更有效(通过良好的实现)。

编辑:

所以,出于好奇,我实现了线性算法的简单版本,并将其与 C++ STL sort() 函数进行了比较。这是我的结果——它们表明,正如我所料,平均而言,线性算法总是比排序好——即使在线性算法理论上最坏的情况下,你需要一个更大的数组才能获胜。以下是我的性能数据:

        N        Sort      Linear      Common
       32,        378,        170,        116
       64,        831,        447,        237
      128,       1741,       1092,        424
      256,       5260,       2211,        865
      512,      10955,       5944,       1727
     1024,      20451,      10529,       3584
     2048,      38459,      21723,       7011
     4096,      77697,      41023,      14136
     8192,     150630,      82919,      28083
    16384,     311593,     166740,      55978
    32768,     648331,     334612,     111891
    65536,    1329827,     673030,     224665
   131072,    2802540,    1342430,     449553
   262144,    5867379,    2717356,     896673
   524288,   12082264,    5423038,    1798905
  1048576,   25155593,   10941005,    3658716
  2097152,   62429382,   24501189,    8940410
  4194304,  120370652,   44820562,   14843411

N 是问题大小,Sort 是以微秒为单位的排序时间,Linear 是以微秒为单位的线性算法时间,Common 是在每次测试之前随机化数组所花费的时间。请注意,要获得仅在排序和线性算法中花费的时间,您需要从第二列和第三列中的值中减去第四列中的值。如果你愿意我这样做,我会很高兴。尽管如此,很明显线性比排序更快。每个 N 都测试了 100 次,这些是所有 100 次测试的汇总数字(总和)。这是我使用的代码:

  void randomize(unsigned char *data, int n) {
     for(int i = 0; i < n; i++)
        data[i] = (unsigned char)(rand() % 256);

  }

  void sorttest(unsigned char *data, int n) {
     unsigned char results[20];
     sort(data, data + n);
     for(int i = 0; i < 20; i++)
        results[i] = data[i];
  }

  void scantest(unsigned char *data, int n) {
     unsigned char results[20];
     for(int i = 0; i < 20; i++)
        results[i] = data[i];

     for(int i = 20; i < n; i++)
        for(int j = 0; j < 20; j++)
           if(data[i] < results[j]) {
              results[j] = data[i];
              break;
           }
  }


  void dotest(int n)
  {
     unsigned char *data = (unsigned char*)malloc(n);
     timeval t1, t2, t3, t4, t5, t6;

     gettimeofday(&t1, 0);
     for(int i = 0; i < 100; i++) {
        randomize(data, n);
        sorttest(data, n);
     }
     gettimeofday(&t2, 0);


     gettimeofday(&t3, 0);
     for(int i = 0; i < 100; i++) {
        randomize(data, n);
        scantest(data, n);
     }
     gettimeofday(&t4, 0);

     gettimeofday(&t5, 0);
     for(int i = 0; i < 100; i++)
        randomize(data, n);
     gettimeofday(&t6, 0);

     int dt1 = 1000000*(t2.tv_sec - t1.tv_sec) + (t2.tv_usec - t1.tv_usec);
     int dt2 = 1000000*(t4.tv_sec - t3.tv_sec) + (t4.tv_usec - t3.tv_usec);
     int dt3 = 1000000*(t6.tv_sec - t5.tv_sec) + (t6.tv_usec - t5.tv_usec);
     printf("%10d, %10d, %10d, %10d\n", n, dt1, dt2, dt3);
     free(data);
  }

  int main() {
     srand(time(0));
     for(int i = 32; i < 5000000; i*=2) dotest(i);
     return 0;
  }

我邀请任何声称排序同样好的人指出我可以如何修改此基准以更公平/正确,以便排序排在首位。不完全是;随意尝试一下。

【讨论】:

  • 好吧,如果“大”数组的大小为 40,则对其进行排序并获得最小的 20 会更快。对于最小的 20 个元素,对数组进行“排序和切割”会更快小于 2^20。
  • 2^20 的数字只有在你只计算比较并且使用最天真的实现方法时才准确:保持小数组未排序并每次检查整个事物。如果您考虑一下,应该会想到更有效的方法...如果您可以将 20 次比较平均减少到 10 次,则数组的大小只需为 1024。
  • Big O 表示法考虑了最坏情况,而不是平均情况。 :-) 你说得对,理论截止值和实际截止值会有所不同。就我而言,我宁愿在小型阵列上使用“低效”方法(请注意,它仍然以线性时间运行),所以我编写了一种方法来维护。在较小的数组上使用排序并在较大的数组上使用辅助列表的性能增益非常小,老实说,我几乎不会考虑它。我只是提出了一些考虑。 :-)
  • 对于它的价值,界限(例如 Big Oh)是正交的(不同于,无关)情况(最好,平均,最差)。几周前有一个关于区别的好帖子。尽管如此,每次在最坏的情况下...无论如何都可能进行超过 20 次搜索。
猜你喜欢
  • 1970-01-01
  • 2019-05-11
  • 2017-05-12
  • 2017-01-04
  • 2020-03-24
  • 2020-12-11
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多