977. 有序数组的平方

977. 有序数组的平方

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

三种解法：

解法一：暴力求解

class Solution {
    public int[] sortedSquares(int[] nums) {

        int[] arr = new int[nums.length];
        for(int i = 0; i < nums.length; i++)
        {
            arr[i] = nums[i] * nums[i];
        }

        Arrays.sort(arr);
        return arr;

    }
}

解法二：归并排序

首先找出数组分界线，左边全部是负数 右边全部是正数 从数组分界线开始 左右两边的数字两两进行比较 将较小的数字存入新开辟的容器, 如果左右两边的数组还有元素 直接存入容器即可

class Solution{
    public :
        vector<int> sortedSquares(vector<int>& nums)
        {
            int neg = -1;
            //找出分界点
            for(int i = 0; i < nums.size(); i++)
            {
                if(nums[i] < 0)
                {
                    neg = i;
                }
                else
                {
                    break;//nums[i] >= 0 时   neg是最后一个负数的位置
                }
            }

            vector<int> arr;
            //使用二路归并排序  两两进行比较  将较小的数字存入arr容器
            int i = neg,j = neg + 1;

            while(i >= 0 && j < nums.size())
            {
                if(nums[i] * nums[i] > nums[j] * nums[j])
                {
                    arr.push_back(nums[j] * nums[j]);//较小的数字进入容器
                    j++;//下一个Nums[j]接着和nums[i]进行比较
                }
                else if(nums[i] * nums[i] <= nums[j] * nums[j])
                {
                    arr.push_back(nums[i] * nums[i]);
                    i--;
                }
            }


            //如果有一方数组没有进入容器  直接进入
            while(j < nums.size())
            {
                arr.push_back(nums[j] * nums[j]);//较小的数字进入容器
                j++;//下一个Nums[j]接着和nums[i]进行比较
            }

            while(i >= 0)
            {
                arr.push_back(nums[i] * nums[i]);
                i--;
            }
            return arr;
        }
};

解法三：双指针，数组最大的元素 一定是在原来数组的两端 所以将数组两端元素的平方进行比较 将较大的元素插入数组中 从后面写入

class Solution{

    public int[] sortedSquares(int[] nums)
    {

        int left = 0;//指向数组最左边
        int right = nums.length - 1;//指向最右边

        int[] result  = new int[nums.length];
        int write = nums.length - 1;//写入指针

        //双指针解法在于 数组最大的元素  一定是在原来数组的两端  所以将数组两端元素的平方进行比较   将较大的元素插入数组中  从后面写入
        while (left <= right)
        {
            if(nums[left] * nums[left] > nums[right] * nums[right])
            {
                result[write] = nums[left] * nums[left];//存入较大的元素
                write--;
                left++;
            }
            else if(nums[left] * nums[left] <= nums[right] * nums[right])
            {
                result[write] = nums[right] * nums[right];
                right--;
                write--;
            }

        }
        
        return result;
    }
}