双指针的简单使用-算法的第二天

练习之前，复习复习双指针的定义及用法，https://zhuanlan.zhihu.com/p/71643340, 分对撞指针，快慢指针，今天联系的是对撞指针，

第一题，

暴力，也是最容易想到了。

import java.lang.Math;
class Solution {
    public int[] sortedSquares(int[] nums) {
      for(int i=0;i<nums.length;i++){
        nums[i] = (int)Math.pow(nums[i],2);
      }
      Arrays.sort(nums);
      return nums;
    }
}

惨不忍睹，挺拉跨的这对比，

双指针（考虑边界）：

类归并算法core，当然这也在题解的理解上，首先已知数组为有序sorted array；
呐就是将正数和负数（negative）分开，在比较平方后的大小，再小到大顺序存储到ans，当然注意边界问题类似归并（merge）

那就复盘练习：

//import java.lang.Math;
class Solution {
    public int[] sortedSquares(int[] nums) {
      // 需要考虑边界的双指针算法；algorithm；
      // same to the Merge_Algorithm;
      int left = 0;
      int right = nums.length-1;
      int negative = -1;
      for(int i=0;i<nums.length;i++){
        if(nums[i]<0){
          negative = i;
        }else{
          break;
        }
      }
      int[] ans = new int[nums.length];
      int i = negative;
      int j = negative+1;
      int go = left;
      while(i>=0||j<right+1){
        if(i<0){
          ans[go] = nums[j]*nums[j];
          ++j;
        }else if(j==right+1){
          ans[go] = nums[i]*nums[i];
          --i;
        }else if(nums[i]*nums[i]>nums[j]*nums[j]){
          ans[go] = nums[j]*nums[j];
          ++j;
        }else{
          ans[go] = nums[i]*nums[i];
          --i;
        }
        ++go;
      }
      return ans;
    }
}

双指针（对撞）：

和第二种基本类似，区别是，这个方法从两端开始向中间走（因为，正负数平方后，两端开始向中间走，都是逐渐变小），谁大就把它放到结果数组的最后，一次存放。最后，ans 必定是一个一次增大的有序数组。

import java.lang.Math;
class Solution {
    public int[] sortedSquares(int[] nums) {
      // 需要考虑边界的双指针算法；algorithm；
      // same to the Merge_Algorithm;
      int left = 0;
      int right = nums.length-1;
     int[] ans = new int[right+1];
     int go = right;
     while(left<=right){
       if(nums[left]*nums[left]<nums[right]*nums[right]){
         ans[go]=nums[right]*nums[right--];
       }else{
         ans[go]=nums[left]*nums[left++];
       }
       go--;
     }
      return ans;
    }
}

练习第二题，

有一说一，第一反应，就是用队列，利用FIFO原理，k有多少，就取出多少又让他进去。
最后排列出来的就是最终ans数组了。
话不多说，并未关心算法复杂度，就开写：

import java.util.LinkedList;
import java.util.Queue;
class Solution {
    public void rotate(int[] nums, int k) {
        // the thinking of the queue;
        Queue<Integer> queue = new LinkedList<Integer>();
        for(int i=nums.length-1;i>=0;i--){
          queue.offer(nums[i]);
        }//
        while(k>0){
           int temp = queue.poll();
           queue.offer(temp);
           k--;
        }
        for(int i=nums.length-1;i>=0;i--){
          nums[i]=queue.poll();
        }
    }
}

额，当然，惨不忍睹：

还想到其他方法，比如，另开辟一个数组，还有和约瑟夫环很像的方法core原理，就没写了，直接跑去看官解。前两个和我想得差不多叭，不过约瑟夫这个我倒是忘了怎么写估计写的话就得现推一下公式了。。。