leedcode【977】有序数组的平方_Java解法

Problem: 977. 有序数组的平方

1. 题目
2. 思路
3. 解题方法
4. 复杂度
5. Code
6. 效能

题目

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序

进阶：

请你设计时间复杂度为 O(n) 的算法解决本问题

思路

1.找到正负分界下标
2.从分界线开始 计算平方值 放入输出数组中

解题方法

1. 二分法找绝对值最小的值的下标
2. 双指针法获取输出数组

复杂度

时间复杂度:

O(n)

空间复杂度:

O(1)

Code

Java

class Solution {
    public static int[] sortedSquares(int[] nums) {
        if(nums == null || nums.length == 0){
            return nums;
        }
        //1. 找到nums正负分界下标
        int loc = getMidLoc(nums);
        int[] result = new int[nums.length];
        int n = 0;
        result[n++] = nums[loc] * nums[loc];
        int left = loc-1, right = loc+1;
        while(left >= 0 && right <= nums.length-1){
            int leftNum = nums[left] * nums[left];
            int rightNum = nums[right] * nums[right];
            if(leftNum <= rightNum){
                result[n++] = leftNum;
                left--;
            } else {
                result[n++] = rightNum;
                right++;
            }
        }
        while(left >= 0){
            int leftNum = nums[left] * nums[left];
            result[n++] = leftNum;
            left--;
        }
        while(right <= nums.length-1){
            int rightNum = nums[right] * nums[right];
            result[n++] = rightNum;
            right++;
        }
        return result;
    }

    /**
     * 获取绝对值最小的值对应的下标(二分法）
     * 数组可能的情况：1、空(主函数处理） 2、全正数 3、全负数 4、正负均有
     * @param nums
     * @return
     */
    public static int getMidLoc(int[] nums){
        int len = nums.length - 1;
        if(nums[0] >= 0){
            return 0;
        }
        if(nums[len] <= 0){
            return len;
        }
        int left = 0, right = nums.length - 1;
        while(left <= right){
            int mid = left + (right - left)/2;
            if(nums[mid] > 0){
                right = mid - 1;
            } else if(nums[mid] < 0){
                left = mid + 1;
            } else {
                return mid;
            }
        }
        return nums[left]*nums[left] <= nums[right]*nums[right] ? left: right;
    }
}

效能