Algorithm 如何检查数组是否只包含时间复杂度为n logn的不同元素

到目前为止，我的工作是在上面，时间复杂度为n^2，有人能帮助提高效率到nlogn或更低吗

    bool checkDuplicates( int array[], int n)
    {
     int i,j;
     for( i = 0; i < n; i++ )
     {
      for( j = i+1; j < n; j++ )
      {
       if( array[i] == array[j] )
        return true;
      }
     }
     return false;
    }

bool检查重复项（int数组[]，int n）
{
int i，j；
对于（i=0；i

假设您可以更改

数组

，请先执行此操作（如果您使用的是好的算法，则为n log n）。接下来，遍历数组并比较顺序元素（n）。

您可以对数组进行快速排序（n log（n）），然后查找重复项变成线性（只需检查连续元素）。

使用排序算法（例如，具有O（n log n）的mergesort），然后检查相等的连续元素。 或者修改mergesort的合并步骤以检测相等的元素。

---

此外，使用SIZEZT来做索引，而不是INT.< /P> < P>如果使用C++，那么这是一种方式：

#包括
布尔具有重复项（int数组[]，int n）
{
std：：设置无重复项（数组，数组+n）；
不返回重复项。大小（）！=n；
}

您可以使用，甚至可以实现您的任务

• 如果可以更改数组的内容，请选择排序
• 如果无法更改数组的内容，则set是一个不错的选择
• 如果您无法更改数组的内容&希望实现

  O（N）

  complexity，请选择无序映射

使用排序

//使用排序检查重复项，复杂性：O（nlog（n））
bool-checkDuplicatesWithSorting（整数数组[]，整数n）
{
排序（数组，数组+n）；
对于（int i=1；i

使用集

//使用集合检查重复项，复杂性：O（nlog（n））
布尔校验重复开关集（int数组[]，int n）
{
设置s（数组，数组+n）；
返回s.size（）！=n；
}

使用无序映射

//使用无序映射检查重复项，复杂性：O（n）（平均情况）
bool checkDuplicatesWithHashMap（int数组[]，int n）
{
无序的马普地图；
for（int i=0；i
log（n）
建议使用二叉搜索树。在二叉树中逐个插入节点，如果插入时存在任何重复，则节点不明显。最坏情况下的复杂度仍然可以是
n^2
也可以使用哈希集将预期复杂度降低到O（n）（尽管一个糟糕的实现会有很多冲突）
// Checking duplicates with Sorting, Complexity: O(nlog(n))
bool checkDuplicatesWithSorting(int array[], int n)
{
 sort(array, array+n);
 for(int i = 1; i < n; i++ )
 {
    if(array[i]==array[i-1])
        return true;
 }
 return false;
}

// Checking duplicates with a Set, Complexity: O(nlog(n))
bool checkDuplicatesWithSet(int array[], int n)
{
 set <int> s(array, array+n);
 return s.size() != n;
}

// Checking duplicates with a Unordered Map, Complexity: O(n) (Average Case)
bool checkDuplicatesWithHashMap(int array[], int n)
{
 unordered_map<int, bool>uo_map;
 for(int i=0;i<n;i++){
    if(uo_map.find(array[i]) ==  uo_map.end())
        uo_map[array[i]] = true;
    else return true;
 }
 return false;
}