Arrays 查找数组中第N个最频繁数的算法

我想写一个算法，找到数组中第n个最频繁的数字。 我有一个解决方案，但不是最优的（测试我已经测试过的数字） 我想知道是否有更理想的解决方案？ 以下是我的解决方案：

most_freq_element(a,n){
final_cnt = 0, curr_cnt = 1, final_freq_num = -1, curr_freq_num = -1;
for(i = 0; i < n-1; i++)
{
    if (a[i]!=-1){
        curr_freq_num = a[i];
        for(j =i+1; j < n; j++){
            if(curr_freq_num == a[j] && final_freq_num != curr_freq_num){
                curr_cnt++;
            }
        }
        if(final_cnt < curr_cnt){
            final_cnt = curr_cnt;
            curr_cnt = 1;
            final_freq_num = curr_freq_num;
        }
    }
}
printf("Num = %d and times = %d", final_freq_num, final_cnt);
}



nth_most_frequent_element(a,n,k){    
if(k==1){
    return most_freq_element(a,n);
}
else{ 
    for (i=0;i<k;i++){
        int most_freq_num = most_freq_element(a,n);

        for(i = 0; i < n-1; i++){
            if (a[i]==most_freq_num){
                a[i]=-1;
            }
        }
    }
    return most_freq_element(a,n);
}
}

most\u freq\u元素（a，n）{
final\u cnt=0，curr\u cnt=1，final\u freq\u num=-1，curr\u freq\u num=-1；
对于（i=0；i对于（i=0；i这如何？最复杂的是O（2.N.logN+k.min（k，d）），d:a中唯一值的数量

most_freq_element(a[0..n-1],n,k)
{
  count[0..k], value[0..k];   // k + 1 elements
  i, j, l;

  qsort(a, n)

  j = 0;
  l = 0;
  value[0] = a[0];
  count[0] = 1;
  for (i = 1; i < n; ++i)
  {
     if (a[i] != value[j])
     {
        if (++l > k) l = k;
        j = l;
        value[j] = a[i];
        count[j] = 0;
     }

     ++count[j];

     while (j > 0 && count[j] > count[j - 1])
     {
        swap(count[j], count[j - 1]);
        swap(value[j], value[j - 1]);
        --j;
     }
  }
  printf("Num = %d and times = %d", value[k - 1], count[k - 1]);
}

most_freq_元素（a[0..n-1]，n，k）
{
计数[0..k]，值[0..k]；//k+1个元素
i、 j，l；
qsort（a，n）
j=0；
l=0；
值[0]=a[0]；
计数[0]=1；
对于（i=1；ik）l=k；
j=l；
值[j]=a[i]；
计数[j]=0；
}
++计数[j]；
而（j>0&&count[j]>count[j-1]）
{
交换（计数[j]，计数[j-1]）；
互换（价值[j]，价值[j-1]）；
--j；
}
}
printf（“Num=%d和times=%d”，值[k-1]，计数[k-1]）；
}
我可能会制作一个hashmap/表，并在冲突时增加每个值，这样数字就是键，值就是冲突的数量。然后，完成后，将其聚合到一个排序列表并获取第n个元素。将在O（n）中运行，这是非常优化的

编辑：实际上，排序将花费n*log（n）。
可能重复的
将其聚合到排序列表中
将使其成为O（nlog（n））您不计算N个哈希映射键查找，它们与nlogn相比是无关紧要的。当操作接近无穷大时，唯一重要的项是nlogn。您看不到包括每个无关紧要项在内的许多算法。它们只是提出了最重要的项，除非有多个相等重要性的项总和{N=1..N-1}（log（N-N））这不是不重要的，因为它大于N。这是一次循环，通过链表进行冲突计数，并为O（N）插入固定时间的hashmap，然后从条目O（nlogn）->O（nlogn）创建一个排序列表，然后获取第N个元素，最大值为O（N）或为排序数组获取O（1）。因此，它是O（3n+nlogn）->O（nlogn）.我不知道你指的是什么。