LeetCode From Easy To Hard No8[Easy]: Squares of a Sorted Array

Given an array of integers A sorted in non-decreasing order, return an array of the squares of each number, also in sorted non-decreasing order.

Example 1:

Input: [-4,-1,0,3,10]
Output: [0,1,9,16,100]

Example 2:

Input: [-7,-3,2,3,11]
Output: [4,9,9,49,121]

Note:

1. 1 <= A.length <= 10000
2. -10000 <= A[i] <= 10000
3. A is sorted in non-decreasing order.

分析：给定一个整数有序的递增数组，返回一个新数组，新数组中每个元素为旧数组元素的平方值，返回的新数组也要是有序的递增数组。

一开始想到的是数组每个元素进行平方后用Arrays.sort()方法排序, 时间复杂度是O(nlogn), 解法如下：

import java.util.*;

class Solution {
    public int[] sortedSquares(int[] A) {
        int[] result = new int[A.length];
        for (int i = 0; i < A.length; i++) {
            result[i] = A[i] * A[i]; // 先返回新数组
        }
        Arrays.sort(result); // 再进行排序
        return result;
    }

    public static void main(String[] args) {
        int[] A = {-4,-1,0,3,10};
        System.out.println(Arrays.toString(new Solution().sortedSquares(A)));

    }

参考Disccuss里边大牛的解法，可以使用双指针优化时间复杂度后为O(n):

import java.util.*;

class Solution {
    public int[] sortedSquares(int[] A) {
        int n = A.length;
        int[] result = new int[n];
        int left = 0; // 左指针（从数组第一个元素开始）
        int right = n - 1; // 右指针（从数组最后一个元素开始）
        for (int i = n - 1; i >= 0; i--) {
            if (Math.abs(A[left]) > Math.abs(A[right])) { // 由于原数组是有序递增的，如果元素左边的元素绝对值大于右边元素，则原数组左边元素的平方值就从新数组最右边开始存放，否则就从左边开始存放
                result[i] = A[left] * A[left];
                left++; // 元素组左边元素比右边大，左指针往右挪一位
            } else {
                result[i] = A[right] * A[right];
                right--; // 右指针往左挪一位
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[] A = {-7,-3,2,3,11};
        System.out.println(Arrays.toString(new Solution().sortedSquares(A)));

    }
}

再看看下边例子巩固下双指针：

给定一个递增的正整数序列和一个正整数target，求序列中的两个数a和b，使得他们的和恰好为target，输出所有满足条件的方案

public class Test {
    public static void main(String[] args) {
        int[] A = {1, 2, 3, 4, 5, 6, 7, 8}; // 递增的正整数序列
        int target = 8;  //
        int n = A.length;
        int left = 0; // 左指针
        int right = n - 1; // 右指针
        for (int i = 0; i < n && left < right; i++) {
            if (A[left] + A[right] == target) { // 若刚好满足条件，则左右指针都挪动一位
                System.out.printf("%s = %s + %s \n", target, A[left], A[right]);
                left++;
                right--;
            } else if (A[left] + A[right] < target) { // 若左右相加小于target，则左指针往右挪动一位（原数组为递增）
                left++;
            } else { // 否则，右指针往左挪动一位
                right--;
            }
        }

    }
}