二倍数对数组(Java)

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

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

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

示例 3：
输入：[4,-2,2,-4]
输出：true
解释：我们可以用 [-2,-4] 和 [2,4] 这两组组成 [-2,-4,2,4] 或是 [2,4,-2,-4]

示例 4：
输入：[1,2,4,16,8,4]
输出：false

提示：
    0 <= arr.length <= 30000
    arr.length 为偶数
    -100000 <= arr[i] <= 100000

把所有的数都用上，并且满足后一个数是前一个数的2倍；
即：2 * arr[0] == arr[1], 2 * arr[2] == arr[3]，以此类推；
注意:arr[1]和arr[2]没要求.

package com.loo;

import java.util.Map;
import java.util.HashMap;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Deque;
import java.util.LinkedList;

public class DoubleNumbers {

    public static void main(String[] args) {
        int[] arr = new int[] {4,-2,2,-4};
        int[] arr2 = new int[] {3,1,3,6};
        int[] arr3 = new int[] {2,1,2,6};
        int[] arr4 = new int[] {1,2,4,16,8,4};
        System.out.println(isDoubleNumbers(arr));
        System.out.println(isDoubleNumbers2(arr));
    }

    // 按照绝对值大小检查整个数组。当检查到元素 i 并且没有被使用时，它一定要配对 2*i。我们将尝试记录 i，2i。如果没有元素 2i 则返回答案 false。如果所有元素都被访问，答案是 true。
    public static boolean isDoubleNumbers(int[] arr) {
        Map<Integer , Integer> count = new HashMap<Integer , Integer>();
        for (int i : arr) {
            count.put(i , count.getOrDefault(i , 0) + 1);
        }
        Integer[] B = new Integer[arr.length];
        for (int i=0;i<B.length;i++) {
            B[i] = arr[i];
        }
        Arrays.sort(B , Comparator.comparingInt(Math::abs));
        for (int j : B) {
            if (count.get(j) == 0) {
                continue;
            }
            if (count.getOrDefault(2*j , 0) <= 0) {
                return false;
            }
            count.put(j , count.get(j) - 1);
            count.put(2*j , count.get(2*j) - 1);
        }
        return true;
    }
    // 排序+队列
    // 首先是对数组 arr 进行排序,使数组元素呈升序排列,
    // 声明一个队列记录数组元素的倍数:
    // (1) 数组元素为负数时,队列添加该元素的 1/2;
    // (2) 数组元素为非负数时,队列添加该元素的 2 倍数.
    // 从头遍历数组 arr ,对于遍历到数组 arr 的每一个元素,进行如下操作:
    // (1) 若队列非空,判断该数是否等于队列的首位元素,若等于,则删除队列的首位元素;否则将该元素的倍数添加到队列末尾;
    // (2) 若队列为空,则直接将该元素的倍数添加到队列中.
    // 遍历完数组 arr 后,判断队列是否为空,若队列非空,则返回 false;否则,返回true.
    // (优化:遍历过程中,当遍历到的数组元素不等于队列的首位元素,且该元素大于队列首位元素时,直接返回 false)
    public static boolean isDoubleNumbers2(int[] arr) {
        int[] B = new int[arr.length];
        System.arraycopy(arr , 0 , B , 0 , B.length);
        Arrays.sort(B);
        Deque<Integer> deque = new LinkedList<Integer>();
        int index = 0;
        while (index < B.length) {
            if (deque.peekFirst()==null) {
                if (B[index] < 0) {
                    deque.addLast(B[index]/2);
                } else {
                    deque.addLast(B[index]*2);
                }
            } else if (deque.peekFirst()!=null) {
                if (deque.peekFirst() == B[index]) {
                    deque.pollFirst();
                } else {
                    if (deque.peekFirst()>B[index]) {
                        if (B[index] < 0) {
                            deque.addLast(B[index]/2);
                        } else {
                            deque.addLast(B[index]*2);
                        }
                    } else {
                        return false;
                    }
                }
            }
            index++;
        }
        if (deque.peekFirst()!=null) {
            return false;
        }
        return true;
    }
}