数组相关问题的时间复杂度答案

【问题标题】：Time complexity for the array related problem数组相关问题的时间复杂度
【发布时间】：2020-05-12 14:11:54
【问题描述】：

给定一个由 N 个整数组成的非空数组 A。该数组包含奇数个元素，并且该数组的每个元素都可以与另一个具有相同值的元素配对，除了一个未配对的元素。

例如，在数组 A 中：

A[0] = 9 A[1] = 3 A[2] = 9 A[3] = 3 A[4] = 9 A[5] = 7 A[6] = 9 索引 0 和 2 处的元素的值为 9，索引 1 和 3 处的元素的值为 3，索引 4 和 6 处的元素的值为 9，索引 5 处的元素的值为 7 并且未配对。写一个函数：

类解决方案 { public int solution(int[] A); }

给定一个由满足上述条件的 N 个整数组成的数组 A，返回未配对元素的值。

例如，给定数组 A 使得：

A[0] = 9 A[1] = 3 A[2] = 9 A[3] = 3 A[4] = 9 A[5] = 7 A[6] = 9 该函数应返回 7，如上例所述。

为以下假设编写一个有效的算法：

N 是 [1..1,000,000] 范围内的奇数；数组 A 的每个元素都是 [1..1,000,000,000] 范围内的整数； A 中除一个以外的所有值都出现偶数次。

我的解决方案

我的解决方案在这些情况下失败了，我愿意从 SO 社区指导我如何思考这个问题，以便我能够克服这些失败

class Solution {
    public int solution(int[] A) {
       int[] result = new int[(int) Math.ceil((double)A.length/2)];
       for(int x = 0 ; x < result.length ; x++ ){
           result[x] = -1;
       }
       for(int x = 0 ; x < A.length ; x++ ){
           for(int y = 0 ; y < result.length ; y++){
               if(result[y] > -1  && result[y]== A[x])
               {
                   result[y] = -2;
                   break;
               }
               if(result[y] == -1 )
               {
                   result[y] = A[x];
                   break;
               }
           }
       }

       for(int x = 0 ; x < result.length ; x++ ){
           if(result[x] > -1){
           return result[x];
           }
       }
       return -1;
    }
}

失败

中等随机测试 n=100,003 被杀。达到硬限制：7.000 秒。

大随机测试 n=999,999，多次重复被杀。达到硬限制：14.000 秒。

大随机测试 n=999,999 被杀。达到硬限制：19.000 秒。

【问题讨论】：

由于大输入的大小为 1000000，您必须考虑如何在线性或最坏的 O(n log n) 时间内解决它。通常，只有当最大的测试用例大小约为 1000 时，编程网站问题才有 O(n^2) 的解决方案。

标签： java algorithm time-complexity

【解决方案1】：

如果保证输入只有一个不成对的元素，那么通过对所有元素进行异或来识别它是非常简单的。

int x = A[0];
for ( int i = 1; i < A.length; i++ )
     x = x ^ A[i];

结果值是未配对的值。

例子：

public static void main (String[] args) throws java.lang.Exception
    {
        int[] A = {9, 3, 9, 2, 4, 2, 4, 7, 3};
        int x = A[0];
        for ( int i = 1; i < A.length; i++ )
            x = x ^ A[i];
        System.out.println(x);
    }

输出为 7。

时间复杂度为O(n)

这是有效的，因为数字与自身的 XOR 为零。

【讨论】：

【解决方案2】：

最有效的解决方案是利用按位异或运算的有趣特性：

a xor a = 0

对于a 的任何值，因此对所有数组项进行异或运算只会给出未配对的值

public int solution(int[] A) {
   int result = 0;
   for(int x = 0 ; x < A.length ; x++ )
       result ^= A[x];
   return result;
}

【讨论】：