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

va 代码如下：

import java.util.Arrays;

public class Solution {
    public boolean canReorder(int[] arr) {
        // 先将数组按照绝对值从小到大排序
        Arrays.sort(arr, (a, b) -> Math.abs(a) - Math.abs(b));
        int n = arr.length;
        int count = 0;  // 记录负数的个数
        for (int i = 0; i < n; i++) {
            if (arr[i] < 0) {
                count++;
            }
        }
        if (count % 2 != 0) {  // 如果负数个数为奇数，则无法满足条件
            return false;
        }
        int[] newArr = new int[n];
        int i = 0;
        int j = n - 1;
        for (int k = n - 1; k >= 0; k--) {
            if (arr[k] % 2 == 0) {  // 如果是偶数，则放在新数组的后半部分
                newArr[j--] = arr[k];
            } else {  // 如果是奇数，则放在新数组的前半部分
                newArr[i++] = arr[k];
            }
        }
        for (int k = 0; k < n / 2; k++) {  // 检查是否满足条件
            if (newArr[2 * k + 1] != 2 * newArr[2 * k]) {
                return false;
            }
        }
        return true;
    }
}

该算法的时间复杂度为 $O(n \log n)$，其中 $n$ 是数组的长度。主要的时间复杂度来自于排序操作。该算法的空间复杂度为 $O(n)$，主要来自于新建的数组。