1005. K 次取反后最大化的数组和

题意：给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：
选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。
重复这个过程恰好 k 次。可以多次选择同一个下标 i 。
以这种方式修改数组后，返回数组 可能的最大和 。

解题思路

解法1：
1.将nums分为两个数组，正数数组和负数数组
2.将负数数组排序，优先将负数数组处理k个，转换为正数，并且加入正数数组，同时需要从负数数组中移除
3.此时将正数数组，重新排序，将最小的正数（即第一个正数）取k%2次反，然后求和即可

解法2：
1.基于原数组去操作，相同的思想，先对nums排序，尽可能（k有可能大于负数个数，此时不再取反）的取反前面的k个负数
2.对nums排序，如果k依然有剩余，则将第一个元素取k%2次反，然后求和即可

解题遇到的问题

无

后续需要总结学习的知识点

无

##解法1
import java.util.Collections;
import java.util.LinkedList;

class Solution {

    public int largestSumAfterKNegations(int[] nums, int k) {
        // 将nums分为两个数组，正数数组和负数数组
        // 优先将负数数组处理k个，转换为正数，并且加入正数数组
        // 如果k此时等于0，则此时数组元素之和，即为最大和
        // 如果k此时依然大于0，则此时将正数数组，重新排序，将最小的正数取k%2次反，然后求和即可
        LinkedList<Integer> bigArrayList = new LinkedList<Integer>();
        LinkedList<Integer> smArrayList = new LinkedList<Integer>();
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] >= 0) {
                bigArrayList.add(nums[i]);
            } else {
                smArrayList.add(nums[i]);
            }
        }
        Collections.sort(smArrayList);
        long ans = 0;
        if (smArrayList.size() >= k) {
            for (int i = 0; i < k; i++) {
                bigArrayList.add(-smArrayList.get(0));
                smArrayList.removeFirst();
            }
        } else {
            for (int i = 0; i < smArrayList.size(); i++) {
                bigArrayList.add(-smArrayList.get(i));
            }
            k = k - smArrayList.size();
            smArrayList.clear();
            Collections.sort(bigArrayList);
            if (bigArrayList.size() > 0) {
                bigArrayList.set(0,
                        k % 2 == 0
                                ? bigArrayList.get(0)
                                : -bigArrayList.get(0));
            }
        }
        for (int i = 0; i < bigArrayList.size(); i++) {
            ans += bigArrayList.get(i);
        }
        for (int i = 0; i < smArrayList.size(); i++) {
            ans += smArrayList.get(i);
        }
        return (int) ans;
    }
}

##解法2：
class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        // 排序，把可能有的负数排到前面
        Arrays.sort(nums);
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            // 贪心：如果是负数，而k还有盈余，就把负数反过来
            if (nums[i] < 0 && k > 0) {
                nums[i] = -1 * nums[i];
                k--;
            }
            sum += nums[i];
        }
        Arrays.sort(nums);
        // 如果k没剩，那说明能转的负数都转正了，已经是最大和，返回sum
        // 如果k有剩，说明负数已经全部转正，所以如果k还剩偶数个就自己抵消掉，不用删减，如果k还剩奇数个就减掉2倍最小正数。
        return sum - (k % 2 == 0 ? 0 : 2 * nums[0]); 
    }
}