Sorting 排序数组算法-重复值

我有一个整数数组，大小为N，值重复，但我不知道值的范围。 我在这个数组中有n/logn个不同的值，其余的都是重复的

是否有一种方法可以按时间复杂度O（n）和内存复杂度O（n/logn）对其进行排序？

气泡排序需要O（n^2）时间，几乎不需要内存即可执行（存储原始数组除外）-请参阅。不过，快速排序要快得多-请参阅

重复项不会影响这两种算法中的任何一种

Mergesort，例如，它是一种具有O（n）空间复杂度的O（n*lg（n））时间算法

您可以使用散列映射将n/lg（n）个唯一项提取到它们自己的数组中，并记录每个项出现的次数；这是（预期的）O（n）时间和O（n/lg（n））空间。现在，您可以在新阵列上运行Mergesort，即：

O（x*lg（x））时间x=n/lg（n）=
O（n/lg（n）*lg（n/lg（n））==
O（n/lg（n）*[lg（n）-lg（lg（n）））==
O（n-n*lg（lg（n））/lg（n））

---

可能您可以使用这个：

#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
using namespace std;
int main()
{
    int n=7;

    int v[]={4,1,2,3,2,4,1}; // initial array

    map<int,int>mp;
    vector<int>uni;

    for(int i=0;i<n;i++)
      if(++mp[v[i]]==1) // counting instance of unique values
        uni.push_back(v[i]); // unique value

    sort(uni.begin(),uni.end()); // sorting : O ((n / logn) * logn) = O(n)

    int cur=0;
    for(int i=0;i<uni.size();i++)
    {
        int cnt=mp[uni[i]];
        while(cnt)  // Adding duplicate values
        {
            v[cur++]=uni[i];
            cnt--;
        }
    }

    for(int i=0;i<n;i++) // Printing final sorted array
      cout<<v[i]<<" ";
    cout<<"\n";
return 0;
}

#包括
#包括
#包括
#包括
使用名称空间std；
int main（）
{
int n=7；
int v[]={4,1,2,3,2,4,1}；//初始数组
mapmp；
向量；
对于（inti=0；i只需保留键值对

 for(i=0;i<n;i++)
    {
int key = a[i];
//       if value is in map increase vale of this key
// else add key with value 1 
    } 

for（i=0；iyes，我想你可以在那种情况下用O（n）对数组进行排序。这是家庭作业吗？@Andras是的。这对我来说是新的，我有点困惑。让我们一步一步来看看。排序是一个O（m log m）操作。你有m=n/logn项，O（m*log m）=O（n/logn*log（n/logn））Andras，这不太正确。对于bbst，重复检查会消耗O（n*log（n/log（n））时间。在我的回答中，我使用哈希表来实现重复检查的预期O（n）时间。@robin但冒泡排序在好的情况下是O（n）。我需要在平均情况下是O（n）的算法。更新mp[v[I]]可能会有O（n^2）最坏的情况成本（如果所有哈希键发生冲突）。哈希算法和数据结构也必须指定给gaurantee O（logn）查找和更新。在最坏的情况下，您如何说O（n^2）？map（sorted）查找的复杂性为O（logn）。因此复杂性为O（n*logn）最坏情况下的最大值。这并不完全正确。对于bbst，重复检查消耗O（n*log（n/log（n）））时间。在我的回答中，我使用哈希表来实现重复检查的预期O（n）时间。正如Andras提到的，哈希表的最坏情况查找/插入是O（n）；但是，它们的使用通常就像是摊销O（1）次一样（也就是说，它们的使用通常就像哈希函数是完美的一样）。@KevinL.Stern映射的最坏情况查找是O（logn）。它使用二进制搜索来搜索值是的，但是您要进行n次查找（对于原始数组的每个元素）。由于mp的大小只会增加到n/log（n）（因为它只包含非重复项），因此重复检查的大小为O（n*log（n/log（n））。问题是O（n）的时间复杂性。对于您的进程，它将转到O（n logn）