数组03_有序数组的平方

有序数组的平方

给定有序数组（既包含整数又包含复数），将其中元素依次平方，并且排序

• 直接平方排序

  首先将数组的元素依次平方放在原数组当中，然后再将原数组使用快速排序算法进行排序

  插入排序 ：O(n_2)：依次放置每个数组元素，给每个数组中的元素依次寻找合适位置

  希尔排序：O(n_1.3)：选择一定的gap，将间距为gap的两个元素交换排序，然后不断减小gap，直至gap=1

  选择排序：O(n_2)：从数组中依次找最小的，次小的，依次类推

  冒泡排序：O(n_2)：依次比较1、2元素，2、3元素，3、4元素，…将大的元素后移，一趟完成后，最大的元素将位于最后面，一直进行n-1趟

  快速排序：O(nlogn)：给定一个元素，将比该元素小的元素放在该元素前面，比该元素小的放在该元素后面，具体来说，以第一个元素为指定元素，用一个索引k来表示目前比指定元素小的元素的数量，若第i个元素比指定元素小，则k+1，然后交换第k+1个元素和第i个元素。

  排序算法：或者一直把指定元素另外保存，然后从后面开始j–，从后向前找到比指定位置元素小的索引为j，将j处的元素放置i处，i+1，然后从前向后i++，找到比指定位置元素小的索引为i，然后将i处的刚在j位置，再从后向前，…。

  class Solution {
  public:
      vector<int> sortedSquares(vector<int>& nums) {
          for(int i = 0; i < nums.size(); i++)
              nums[i] = nums[i] * nums[i];
          quickSort(nums, 0, nums.size()-1);
          return nums;
      }
      // 快速排序算法
      void quickSort(vector<int>& nums, int p, int q)
      {
          if (p >= q) return;
          int valRef = nums[p];
          int i = p, j = q;
          while(i < j)
          {
              while(i < j && valRef < nums[j]) j--;
              if (i < j) 
              {
                  nums[i] = nums[j];
                  i++;
              }
              while(i < j && valRef > nums[i]) i++;
              if(i < j)
              {
                  nums[j] = nums[i];
                  j--;
              }
          }
          nums[i] = valRef;
          quickSort(nums, p, i-1);
          quickSort(nums, i+1, q);
      }
  };
  

• 双指针法（头尾指针法）

  借助原来数字有序的特点，有序数组的平方比较大的数必然出现在两头

  用 left 和 right 表示从头向后移、和从后向前移动的数组索引，每次比较right 处的值与left 处的值，如果nums[left] >nums[right] ，则将nums[left]放置到新数组的right-left 位置处，left++；反之，如果nums[left]<= nums[right]，则放置nums[right]处的值至right-left位置处。

  class Solution {
  public:
      vector<int> sortedSquares(vector<int>& nums)
      {
          int left = 0, right = nums.size()-1;
          int left_squ, right_squ;
          vector<int> res(nums.size());
          while(left <= right)
          {
              left_squ = nums[left]*nums[left];
              right_squ = nums[right]*nums[right];
              if(left_squ < right_squ)
              {
                  res[right - left] = right_squ;
                  right--;
              }
              else
              {
                  res[right - left] = left_squ;
                  left++;
              }   
          }
          return res;
      }
  };