LeetCode 977. 有序数组的平方 双指针 二分

地址 https://leetcode-cn.com/problems/squares-of-a-sorted-array/

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

 

示例 1：

输入：[-4,-1,0,3,10]
输出：[0,1,9,16,100]
示例 2：

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

提示：

1 <= A.length <= 10000
-10000 <= A[i] <= 10000
A 已按非递减顺序排序。

三种方法都是利用了数组有序和考虑到了 正负数的平方都未正，所以实际大小应该以绝对值比较。
但是在0之前后0之后的数组是已经有序了

算法1
(暴力枚举) 遍历后 答案数组再排序
C++ 代码

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        vector<int> ret;
        for(auto& e:A){
            ret.push_back(e*e);
        }

        sort(ret.begin(),ret.end());

        return ret;
    }
};

算法2
双指针
l作为起点(可能是负数) r作为另一端的起点(整数)
每次取LR中绝对值较大的数字放入答案并且移动(l/r)
最后逆转答案就是从小到大

C++ 代码

class Solution {
public:
    vector<int> ans;
    vector<int> sortedSquares(vector<int>& A) {
        int l = 0; int r = A.size()-1;
        while (l <= r) {
            if (abs(A[l]) > abs(A[r])) {
                ans.push_back(A[l]*A[l]);
                l++;
            }
            else {
                ans.push_back(A[r] * A[r]);
                r--;
            }
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }
};

算法3
算法2的加强版。 算法2如果指针l是负数 那么找到r的位置是进行遍历的
在数组负数较多的情况下 比较慢，使用二分可以再次提速
二分找到 0点之后后再使用双指针
每次取LR中绝对值较大的数字放入答案并且移动(l/r)

class Solution {
public:
    vector<int> ans;

    bool Check(const vector<int>& A, int n,int idx)
    {
        return A[idx] >= n;
    }

    int bsearch(const vector<int>& A, int n)
    {
        int l = 0; int r = A.size()-1;

        while (l < r) {
            int mid = l + r >> 1;
            if (Check(A, n, mid)) r = mid;
            else l = mid +1;
        }
        return l;
    }

    vector<int> sortedSquares(vector<int>& A) {
        int zeroIdx = bsearch(A, 0);
        int l = zeroIdx - 1; int r = zeroIdx;
        while (l >= 0 && l < A.size() && r>=0 && r < A.size()) {
            if (abs(A[l]) >= (A[r])) {
                ans.push_back(A[r] * A[r]);
                r++;
            }
            else {
                ans.push_back(A[l] * A[l]);
                l--;
            }
        }

        while (l >= 0) {
            ans.push_back(A[l] * A[l]);
            l--;
        }

        while (r < A.size()) {
            ans.push_back(A[r] * A[r]);
            r++;
        }

        return ans;
    }
};