LeetCode每日一练、算法（977、有序数组的平方）（189、轮转数组）

题目1：（977、有序数组的平方）

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

 思路一：

最简单的方法是先求平方再排序

思路二：双指针

有两种方法：

1、求得最大的负数的下标i和最小的非负数下标j。定义一个新数组，从0下标开始，比较下标为i和下标为j的两个数的平方数值，将较小者放置在新数组的0下标，然后i--或者j++，直到i<0或者j=n

2、也可以使代码简洁一点，考虑逆序存放元素进入新数组，也就是从后往前（从大到小），起始时一个指针位于0位置，另一个指针位于最后一个元素的位置；接着比较两个数的平方的大小，将较大的数的平方赋值给新数组，再将操作的该指针-1（或+1），直到两个指针相遇

java代码

package demo;

import java.util.Arrays;

public class leetcode11 {
    public int[] sortedSquares(int[] nums) {
        int n=nums.length;
        int[] ans=new int[n];
        for(int i=0;i<n;i++){
            ans[i]=nums[i]*nums[i];
        }
        Arrays.sort(ans);
        return ans;
    }
    public int[] sortedSquares_doublepoint(int[] nums){
        int n=nums.length;
        int i;
        int j;
        int index;
        int[] ans=new int[n];
        for(i=0,j=n-1,index=n-1;i<=j;){
            if(nums[i]*nums[i]<=nums[j]*nums[j]){
                ans[index]=nums[j]*nums[j];
                j--;
            }else {
                ans[index]=nums[i]*nums[i];
                i++;
            }
            index--;
        }
        return ans;
    }
}

class test11{
    public static void main(String arg[]){
        leetcode11 l=new leetcode11();
        int[] nums={-4,-1,0,3,10};
        int[] ans=l.sortedSquares_doublepoint(nums);
        for(int i:ans){
            System.out.println(i);
        }
    }
}

复杂度分析

思路一：

思路二： 

题目2：（189、轮转数组）

 给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

 思路一：定义新数组后拷贝

先定义一个新数组，将轮转后的元素依次放入相应的位置（根据取余操作），最后再将新数组中的元素搬移到原来的数组中。

思路二：三次翻转

1、第一次对整个数组翻转一次

2、第二次对前k个元素翻转

3、第三次对后n-k个元素翻转

我们可以用一个例子来说明这个思路

例如：nums=[1,2,3,4,5,6,7],k=3;

 

 思路三：循环轮转

在这一种思路中我们考虑两种情况：

1、数组中元素数目n和k的最大公约数为1的情况，在这种情况下只需要循环一轮，每一轮替换n+1次（其中最后一次相当于没有替换）

 2、数组中元素数目n和k的最大公约数不为1的情况，在这种情况下需要循环的次数为最大公约数的数值，每一轮替换（n/最大公约数）次（其中最后一次相当于没有替换）

 java代码

package demo;

public class leetcode12 {
    public void rotate(int[] nums, int k) {
        int n=nums.length;
        int[] copy=new int[n];
        for(int i=0;i<n;i++){
            copy[(i+k)%n]=nums[i];
        }
        System.arraycopy(copy, 0, nums, 0, n);
    }
    public void rotate_reverse(int[] nums, int k){
        int n=nums.length;
        k=k%n;
        reverse(nums,0,n-1);
        reverse(nums,0,k-1);
        reverse(nums,k,n-1);
    }
    public void reverse(int[] nums,int begin,int end){
        while (begin<=end){
            int temp=nums[begin];
            nums[begin]=nums[end];
            nums[end]=temp;
            begin++;
            end--;
        }
    }
    public void rotate_classic(int[] nums, int k){
        int n=nums.length;
        k=k%n;
        if(k==0){
            return;
        }
        int round=gcd(n,k);
        int count=round==1?n+1:n/round;
        for(int i=0;i<round;i++){
            int last=nums[i];
            for(int j=1;j<=count;j++){
                int temp=last;
                last=nums[(i+j*k)%n];
                nums[(i+j*k)%n]=temp;
            }
        }
    }
    public int gcd(int x, int y) {
        return y > 0 ? gcd(y, x % y) : x;
    }
}


class test12{
    public static void main(String arg[]){
        leetcode12 l=new leetcode12();
        int[] nums={1,2,3,4,5,6,7};
        int k=3;
        l.rotate_classic(nums,k);
        for(int i:nums){
            System.out.println(i);
        }
    }
}

复杂度分析

思路一：

 思路二：

思路三：

 

Tips：

1、思路二性能比较优异，理解起来更容易

2、实测性能思路三更加出色