力扣-简单-977.有序数组的平方

力扣-简单-977.有序数组的平方

题目描述：

给定一个按非递减顺序排序的整数数组 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 已按非递减顺序排序。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/squares-of-a-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1.对数组A的元素都进行平方后存储进新数组B，对数组B进行排序。

这里可以用的算法如下：

• 直接插入排序
• 折半插入排序
• 选择排序
• 冒泡排序
• 快速排序
• 归并排序
• 基数排序？

/***************************************************************************************/
//	1.直接插入排序
class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {;
        int len = A.size();
        vector<int> res(len);
		for(auto var:A){
            res.push_back(var*var);
        }
       
        int temp;
        for(int i=1;i<len;i++)
        {
            temp = res[i];
            for(int j=i-1;j>0 && temp<res[j];j--)
                res[j+1]=A[j];
            res[j+1] = temp;
        }
        return res;
    }
}
/***************************************************************************************/
//	2.折半插入排序
class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) 
    {
        int len = A.size();
        vector<int> res(len);
		for(auto var:A){
            res.push_back(var*var);
        }
                                               
       int temp;
       for(int i=1;i<len;i++)
       {
           temp = res[i];
           int low = 0,high = i-1;
           while(low <= high)
           {
               m = (low+high)/2;
               if(temp<res[m])
                   high = m-1;
               else
                   low = m+1;
           }
           for(int k = i-1;k>=low;k++)
               res[k+1] = res[k];
           res[low] = tmep;
       }
       return res;
	}
}	
/***************************************************************************************/
//	3.希尔排序
class Solution {
public:
    #define INCRGAP 3
    vector<int> sortedSquares(vector<int>& A) 
    {
        int len = A.size();
        vector<int> res(len);
		for(auto var:A){
            res.push_back(var*var);
        }
        
        int gap = len/INCRGAP + 1;
        int insertNum = 0;
   	 	while(gap) // while gap>=1
    	{
        	for (int i = gap; i < len; ++i) // 分组，在每个子序列中进行插入排序
        	{
            	insertNum = res[i];//将当前的元素值先存起来方便后面插入
            	int j = i;
            	while (j >= gap && insertNum < res[j-gap])//寻找插入位置
            	{
                	res[j] = res[j - gap];
                	j -= gap;
            	}
            	res[j] = insertNum;
        	}
            gap/=INCRGAP;
        }
        return res;
    }
}

/***************************************************************************************/
//	4.选择排序
class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        vector<int> res;
		for(auto var:A){
            res.push_back(var*var);
        }
        
        for(int i=0;i<len;i++)
        {
            int min = i;
            for(int j=i+1;j<len;j++)
            {
                if(res[j]<res[i])
                    min = j;
            }
            if(min!=i)
                swap(res[i],res[min]);
        }
        return res;
    }
}
/***************************************************************************************/
//	5.冒泡排序
class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        vector<int> res;
		for(auto var:A){
            res.push_back(var*var);
        }
        
        int len = A.size();
        for(int i=0;i<len;i++)
            for(int j=1;j<i;j++)
                if(res[i]<res[j]){
                    int temp = res[j];
                    res[j] = res[i];
                    res[i] = temp;
                }
              
    }
};

/***************************************************************************************/
//	6.快速排序
class Solution {
public:
    int Partition(vector<int>& A,int s,int t)
    {
        int x = A[s];
        while(s<t)
        {
            while(s<t && A[t]>x)
                t--;
            if(s<t)
                A[s] = A[t];
            while(s<t && A[s]<x)
                s++;
            if(s<t)
                A[t] = A[s];
        }
        A[s] = x;
        return s;
    }
    
    void QuickSort(vector<int>& A,int first,int end)
    {
        if(first<end)
        {
            pivot = Paratition(A,first,end);
            QuickSort(A,first,end);
            QuickSort(r,pivot+1,end);
        }
    }
    vector<int> sortedSquares(vector<int>& A) {
        vector<int> res;
		for(auto var:A){
            res.push_back(var*var);
        }
        QuickSort(res,0,len-1);
        return res;
    }
}
     
/***************************************************************************************/
//	7.归并排序
class Solution {
public:
	void Merge(vector<int>& A,vector<int>& res,int s,int m,int t)
	{
    	int i=s,j=m+1,k=s;
    	while(i<=m && j<=t)
    	{
        	if(A[i]<=A[j])
            	res[k++] = A[i++];
        	else
            	res[k++] = A[j++];
    	}
    	while(i<=m)
        	res[k++] = A[i++];
    	while(j<=t)
        	res[k++] = A[j++];
    }
    
    void MergePss(vector<int>&A ,vector<int>& res,int n,int h)
    {
        int i=1;
        while(i<=n-2*h+1)
        {
            Merge(A,res,i,i+h-1,i+2*h-1);
         	i+=2*h;
        }
        if(i<n-h+1)
            Merge(A,res,i,i+h-1,n);
        else
            for(int k=i;k<=n;k++)
                res[k] = A[k];
    }
    
    vector<int> sortedSquares(vector<int>& A) {
        int len = A.size();
        vector<int> res(len);
		for(auto var:A){
            res.push_back(var*var);
        }   
        
        int h=1;
        while(h<len)
        {
            Merge(A,res,len,h);
            h *= 2;
            Merge(res,A,len,h);
            h *= 2;
        }
        return A;
    }
}
//	8.基数排序

2.双指针通过移动不断添加剩余最小平方的值进数组

/**************************************************************************************/
//	双指针
//	先遍历数组，找到第一个大于0的数的位置，设它为right，left = right-1
//	比较left位置和right位置的数平方之后的大小
//	如果left的大，则先把right
//	小的先放进去，
/**************************************************************************************/

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        vector<int> res;
        int len = A.size();
        int negative = -1;
        for(auto i:A)
        {
            if(i<0)
                negative++;
            else
                break;
        }

        int i = negative,j=negative+1;
        while(i>=0||j<len)
        {
            if(i<0){
                res.push_back(A[j]*A[j]);
                j++;
            }
            else if(j==len)
            {
                res.push_back(A[i]*A[i]);
                i--;
            }
            else if(A[i]*A[i]>A[j]*A[j]){
                res.push_back(A[j]*A[j]);
                j++;
            }
            else{
                res.push_back(A[i]*A[i]);
                i--;
            }
        }
        return res;
    }
};

3.双指针，逆序存进数组

/**************************************************************************************/
//	由于原本的数组A是有序递增的，那么平方之后最大的值肯定位于下标0或者n-1处
//	所以只要不断比较边界位置的大小
/**************************************************************************************/
class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        int len = A.size();
        int i = 0,j = len-1,pos = j;

        vector<int> res(len);
        while(i<=j)
        {
            if(A[i]*A[i]>A[j]*A[j])
            {
                res[pos] = A[i]*A[i];
                i++;
            }
            else{
                res[pos] = A[j]*A[j];
                j--;
            }
            pos--;
        }
        return res;
    }
};