有序数组的平方

977. 有序数组的平方

package 数组;

import java.util.Arrays;

public class 有序数组的平方 {

    public static void main(String[] args) {
//        int[] arr = {-4, -1, 0, 3, 10};
        int[] arr = {1};
        有序数组的平方 a = new 有序数组的平方();
        int[] ints = a.sortedSquares(arr);
        System.out.println(Arrays.toString(ints));
    }


    // 找到数组的正负值得分界线
    // 正值的平方还是非递减的
    // 负值的平方是非递增的
    // 合并这两块单调区域
    public int[] sortedSquares(int[] nums) {
        if (nums == null || nums.length == 0) {
            return null;
        }
        int[] result = new int[nums.length];
        // 全是正数，直接返回平方
        // 全是负数，平方翻转
        // 有正有负，单独处理
        if (nums[0] >= 0) {
            for (int i = 0; i < nums.length; i++) {
                result[i] = nums[i]*nums[i];
            }
        } else if (nums[nums.length - 1] <= 0) {
            for (int i = 0; i < nums.length; i++) {
                result[i] = nums[nums.length - 1 - i]*nums[nums.length - 1 - i];
            }
        } else {
            int dividIndex = getDividIndex(nums);
            square(nums, result, 0, dividIndex - 1);
            square(nums, result, dividIndex, nums.length - 1);
            result = merge(result, dividIndex);
        }
        return result;
    }

    // 第一个大于等于0的数的索引就是分界线，正数的起点是分界线
    public int getDividIndex(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] >= 0) {
                return i;
            }
        }
        return -1;
    }

    public void square(int[] nums, int[] result, int start, int end) {
        for (int i = start; i <= end; i++) {
            result[i] = nums[i] * nums[i];
        }
    }

    // 合并数组的两块有序区域 {6,4,2,1,5,7}
    public int[] merge(int[] result, int dividIndex) {
        int [] merged=new int[result.length];
        int left = dividIndex-1;
        int right = dividIndex;
        int i = 0;
        while (left >= 0 && right <= result.length-1) {
            if (result[left] <= result[right]) {
                merged[i++] = result[left--];
            } else if (result[left] > result[right]) {
                merged[i++] = result[right++];
            }
        }
        while (left >=0) {
            merged[i++] = result[left--];
        }
        while (right <= result.length - 1) {
            merged[i++] = result[right++];
        }
        return merged;
    }

}

。。