leetcode刷题日记 2021/7/13

leetcode

Question1:

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

class Solution {
    public int[] sortedSquares(int[] nums) {
        for(int i=0;i<nums.length;i++)
        {
            nums[i]=nums[i]*nums[i];
        }
        sort(nums);
        return nums;


    }
    public static void sort(int[] nums)
    {
        for(int i=0;i<nums.length;i++)
        {
            for(int j=0;j<nums.length-1;j++)
            {
                if(nums[j]>nums[j+1])
                {
                    int temp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }
        return ;
    }
}

 我用冒泡排序对数组进行重新排列。
执行用时：1104 ms, 在所有 Java 提交中击败了5.01%的用户
内存消耗：39.7 MB, 在所有 Java 提交中击败了96.75%的用户
因为平方后的数组有一定的规律，所以查看解析后
可以采用双指针的方法。

Question2(leetcode:189):

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

class Solution {
    public void rotate(int[] nums, int k) {
        int[] array=new int[nums.length];
        int length=nums.length;
        for(int i=0;i<nums.length;i++)
        {   
            array[(i+k)%length]=nums[i];
        }   
        for(int i=0;i<nums.length;i++)
        {
            nums[i]=array[i];
        }

    }
}

执行用时：1 ms, 在所有 Java 提交中击败了67.18%的用户
内存消耗：55.4 MB, 在所有 Java 提交中击败了24.79%的用户
思考空间复杂度为O(1)的方法:

class Solution {
    public void rotate(int[] nums, int k) {
        k %= nums.length;
        reverse(nums, 0, nums.length - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.length - 1);
    }

    public void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start] = nums[end];
            nums[end] = temp;
            start += 1;
            end -= 1;
        }
    }
}

数组反转，将数组所有的位置翻转过来，将[0, k mod n]翻转过来，再将[k mod n+1,n-1]翻转过来。