二倍数对数组

二倍数对数组

给定一个长度为偶数的整数数组 arr，只有对 arr 进行重组后可以满足 “对于每个 0 <= i < len(arr) / 2，都有 arr[2 * i + 1] = 2 * arr[2 * i]” 时，返回 true；否则，返回 false。
示例 1：

输入：arr = [3,1,3,6]
输出：false
示例 2：

输入：arr = [2,1,2,6]
输出：false
示例 3：

输入：arr = [4,-2,2,-4]
输出：true
解释：可以用 [-2,-4] 和 [2,4] 这两组组成 [-2,-4,2,4] 或是 [2,4,-2,-4]

提示：

0 <= arr.length <= 3 * 104
arr.length 是偶数
-105 <= arr[i] <= 105

方法一：（哈希+排序）

思路：
首先用一个无序图将数组中每个元素以及出现的个数保存起来；然后对比较元素x和2x元素的个数是否相同即可；
但是考虑到0元素的特殊性，以及负数元素的倍数关系，因此在处理过程中，需要先判断0元素的个数是否为偶数，如果不为偶数，那么直接可以返回false；另外对负数取绝对值即可；

代码如下：

class Solution {
public:
    bool canReorderDoubled(vector<int>& arr) {
        unordered_map<int,int> cnt;
        for(int x : arr){
        	++cnt[x];
        }
        if(cnt[0]%2!=0) return false;
        vector<int> vals;
        vals.reserve(cnt.size());
        for(auto& [x,_] : cnt){//遍历无序图中元素的一种方式
        	vals.push_back(x);
        }
        sort(vals.begin(),vals.end(),[](int a,int b){return abs(a)<abs(b);});
        for(int x : vals){
        	if(cnt[2*x]<cnt[x]) return false;
        	cnt[2*x]-=cnt[x];
        }
        return true;
    }
};

• 时间复杂度： 最坏的情况下，哈希表中有N个元素，那么排序的时间复杂度就是O(NlogN)；
• 空间复杂度： 哈希表中装N个元素，那么空间复杂度为O(N)

方法二：（排序+队列）

思路：
很显然，“成对” 这样的关系，如果能及时的配对消掉，也会是个不错的办法，这样就想到了容器；

讲一下为什么要用队列，而不是用栈，因为栈 “先入后出” 那么每次比较的栈顶是当前更新过后的元素，而我们这里恰恰需要的是将“历史”的元素先消掉，然后一步一步看是否最后能消除 完，从而判断是否满足题意，因此就需要队列 “先入先出”；

其次就是讲下为什么要排序，而且还是先排序，就比如，会存在类似（2,4,0,0,1,8）这样的情况，两组“对”会存在交叉的这样的可能，那么，如果不排序，就会在半路把交叉的部分给消掉了，从而得不到正确的结果；

上代码：

class Solution {
public:
    bool canReorderDoubled(vector<int>& arr) {
        sort(arr.begin(),arr.end());
        queue<int> que;
        for(int x : arr){
            if(que.empty()) que.push(x);
            else{
                int e=que.front();
                if(x==2*e || e==2*x) que.pop();
                else que.push(x);
            }
        }
        return que.empty();
    }
};

• 时间复杂度： 遍历一遍数组O(N)；
• 空间复杂度： 哈希表中装N个元素，那么空间复杂度为O(N)