【力扣】力扣刷题第四天

977. 有序数组的平方

难度简单248收藏分享切换为英文接收动态反馈

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

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：

• 1 <= nums.length <= 104
• -104 <= nums[i] <= 104
• nums 已按 非递减顺序 排序

进阶：

• 请你设计时间复杂度为 O(n) 的算法解决本问题

我的解法：

class Solution {
    public int[] sortedSquares(int[] nums) {

        for(int i=0; i<nums.length; i++){
            nums[i] = nums[i]*nums[i];
        }

        int l = 0, r = nums.length-1;

        return quickSort(nums,l,r);
    }


    int[] quickSort(int[] nums,int l,int r){

        if(l<r){

            int temp = nums[l]; 
            int begin = l; 
            int end = r; 
            while(begin < end){
                while(begin<end && nums[end] > temp)
                    end--;
                nums[begin] = nums[end];
                while(begin<end && nums[begin] <= temp)
                    begin++;
                nums[end] = nums[begin];
            }
            nums[begin] = temp;
            this.quickSort(nums,l,begin-1);
            this.quickSort(nums,begin+1,r);
        }
        else {
            return nums;
        }
        return nums;
    }
}

执行用时：8 ms, 在所有 Java 提交中击败了7.11%的用户

内存消耗：39.6 MB, 在所有 Java 提交中击败了99.15%的用户

官方解法：

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

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/squares-of-a-sorted-array/solution/you-xu-shu-zu-de-ping-fang-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

189. 旋转数组

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

进阶：

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

示例 1:

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]

示例 2:

输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释: 
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]

提示：

• 1 <= nums.length <= 2 * 104
• -231 <= nums[i] <= 231 - 1
• 0 <= k <= 105

我的解法：

class Solution {
    public void rotate(int[] nums, int k) {
        int mid = nums.length-k;
        if(k<nums.length){
           new Solution().nb(mid,nums,k);
        }else if(k>nums.length){
            k = k%nums.length;
            mid = nums.length-k;
           new Solution().nb(mid,nums,k);
        }
    }
    void nb(int mid,int[] nums,int k){
        int[] jg = new int[nums.length];
         for(int i = mid; i<nums.length; i++){
                jg[i-mid] = nums[i];
            }
            for(int i = nums.length-mid; i<nums.length; i++){
                jg[i] = nums[i-k];
            }
            System.arraycopy(jg, 0, nums, 0, nums.length); 
    };
}

/**执行用时：
1 ms, 在所有 Java 提交中击败了66.81%的用户
内存消耗：
55 MB, 在所有 Java 提交中击败了83.59%的用户**/

官方解法：

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

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/rotate-array/solution/xuan-zhuan-shu-zu-by-leetcode-solution-nipk/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。