Leetcode刷题Day2（C#）

977、有序数组的平方

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

解题：

一开始我想得特别复杂，还想正数和负数分开讨论，后来一想，何必啊，它已经是个有序数列了，平方以后，最大值肯定是会两端的数，所以只需要在这个平方以后的数列的头和尾设置两个指针，对比取大就可以了。

思路其实很简单，以某测试用例来表达思路过程：

 代码段如下：

public class Solution {
    public int[] SortedSquares(int[] nums) {
        int[] SquareNums = new int[nums.Length];
        int left = 0;
        int right = nums.Length-1;
        int index = SquareNums.Length-1;
        for (int i =0;i<nums.Length;i++){
            nums[i]= nums[i]*nums[i];
        }
        while(left<=right){
            if(nums[left]<=nums[right]){
                SquareNums[index--]=nums[right];
                right--;
            }
            else{
                SquareNums[index--]=nums[left];
                left++;
            }
        }
        return SquareNums;
    }
}

结果居然一遍过了，太意外了噗🥳

可是距离我开始做这题已过去了两个小时，算法小白，伤不起啊 。。。 

189、旋转数组

题目描述：给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

进阶：

• 尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
• 你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？

解题：

拿到题目，看到提示

 觉得，简单啊，把最后一个数拿下来（确实做到了空间复杂度是O（n）），每次都往后一个位置，多移动几次不就行了嘛，于是代码就是这样的：

public class Solution {
    public int[] Rotate(int[] nums, int k) {  //题目上其实给的是void，但是我私自改了题目
        int Res;
        for(int i=0;i<k;i++){
            Res = nums[nums.Length-1];
            for (int j=nums.Length-1;j>0;j--){
                nums[j]=nums[j-1];
            }
            nums[0]=Res;
        }
        return nums;
    }
}

然后运行，测试用例的确也可以跑出来 ，good

Then正式提交以后，

 果然，每一个简单暴力的思路，都需要有一个“超出时间限制”来毁灭💣

然后我想，那就预留一个大小为k的数组来存放后面“溢出”的那些数字，然后整个的平移一下，思路如下：

思路好像没大毛病🤔，于是代码如下：

public class Solution {
    public int[] Rotate(int[] nums, int k) {
        int[] Res = new int[k];
        for(int i = nums.Length-k;i<nums.Length;i++){
            Res[i-nums.Length+k] = nums[i];
        }
        for(int j =nums.Length-1;j>-1;j--){ //从后往前填数字
            if(j>k-1){
                nums[j]=nums[j-k];
            }
            else{
                nums[j]=Res[j];
            }
        }
        return nums;
    }
}

但这次又有了新大病，然后没过：

 看来就是直接用j-k的表达，很容易就会溢出，于是想到这个k也许不应该是k，而应该是k%nums.length，因为要考虑到nums.length比k小的情况

于是加了一句k=k%nums.Length; 以后——

public class Solution {
    public int[] Rotate(int[] nums, int k) {
        k=k%nums.Length;
        int[] Res = new int[k];
        for(int i = nums.Length-k;i<nums.Length;i++){
            Res[i-nums.Length+k] = nums[i];
        }
        for(int j =nums.Length-1;j>-1;j--){
            if(j>k-1){
                nums[j]=nums[j-k];
            }
            else{
                nums[j]=Res[j];
            }
        }
        return nums;
    }
}

 过了过了过了啊啊啊啊啊啊啊啊啊～～～

以上是另外再开辟一段内存的做法，但是很明显，空间复杂度是O（n），远没达到O（1）的程度

看了一眼官方给的一个解析，还有一下两种进阶方法

1）环状替代：

原理如下图所示：

这里有个重要的数，就是循环的位数k和数组长度nums.length的最小公约数。这决定了需要几次换装替代可以完成数组的旋转，即数组需要gcd（k，nums.Length）【两数的最小公约数】次环状替换，可以完成数组的旋转。

代码如下：

public class Solution {
    public int[] Rotate(int[] nums, int k) {
        k=k%nums.Length;
        int Res;
        int count = 0;
        int remainder = 0;
        int num1 = k;
        int num2 = nums.Length;
//使用辗转相除法求解两数的最小公约数
        while (num1 % num2 > 0) {
            remainder = num1 % num2;
            num1 = num2;
            num2 = remainder; 
            }
            count = remainder;
        for(int i=0;i<count;i++){
            int index = i;
            do{
                index = (index+k)%nums.Length;
                Res = nums[i];
                nums[i] = nums[index];
                nums[index] = Res; 
                }while(index%nums.Length != i);
        }
        return nums;
    }
}

不知道C#有没有便捷的语句可以直接完成两数公约数的求解，我没找到，于是就使用了辗转相除法来求两数的最小公约数。最后的结果如下：

 2）数组翻转：

简单来说，就是先把数组翻转一下，然后前k%nums.Length个数翻转一下，剩下的数组再翻转一下。

规律真的很简单，但是这个窗户纸我自己就是捅不破，气人～～～

不得不说，这个方法确实是非常的香，因为代码只有短短5行，逻辑简单到不行：

public class Solution {
    public int[] Rotate(int[] nums, int k) {
        k=k%nums.Length;
        Array.Reverse(nums);
        Array.Reverse(nums,0,k);
        Array.Reverse(nums,k,nums.Length-k);
        return nums;
    }
}

 

 如果大神们还有什么更好的方法，欢迎在评论区赐教呀～～～