算法刷题-Day02

1. 有序数组的平方

题目描述

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

输入示例

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

思路讲解和代码实现

package com.why.day02;

import java.util.Arrays;

/**
 * @ClassName：SortSquares
 * @Description：todo 有序数组的平方
 *
 * 题目：
 *  给你一个按 非递减顺序 排序的整数数组 `nums`，
 *  返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
 *
 * 输入示例：
 *  输入：nums = [-4,-1,0,3,10]
 *  输出：[0,1,9,16,100]
 *  解释：平方后，数组变为 [16,1,0,9,100]
 *  排序后，数组变为 [0,1,9,16,100]
 *
 * @Author: why
 * @DateTime：2021/10/30 17:02
 */
public class SortSquares {

    public static void main(String[] args) {
        SortSquares sortSquares = new SortSquares();
        int[] nums = {-10000,-1,0,3,10000};
        int[] ints = sortSquares.sortedSquares(nums);
        System.out.println(Arrays.toString(ints));
    }

    /**
     * 思路：
     *  1. 先平方再排序
     * @param nums
     * @return
     */
    public int[] sortedSquares(int[] nums) {
        int top = -1;
        for (int i = 0; i < nums.length; i++) {
            nums[i] = nums[i] * nums[i];
        }

        return bubbleSorting(nums);
    }

    /**
     * 冒泡排序
     * @param arr
     * @return
     */
    public static int[] bubbleSorting(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                if (arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        return arr;
    }
}

2. 旋转数组

题目描述

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

输入示例

输入: 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]

思路讲解和代码实现

解法1

依次循环k此

/**
 * 思路：
 *  数组大小是一个循环
 *  首先用 k mod arr.length = 实际移动的位置
 *  1. 将0 - length-2位置的数据后移1位
 *  2. 末尾数据加入到数组首部
 *  3. 循环k次得到新数组
 * @param nums
 * @param k
 */
public void rotate(int[] nums, int k) {
    k = k % nums.length;

    for (int i = 0; i < k; i++) {
        rightRotate(nums);
    }

    System.out.println(Arrays.toString(nums));
}

/**
 * 右循环1位
 * @param nums
 */
private static void rightRotate(int[] nums){
    //保存末尾位置
    int temp = nums[nums.length-1];

    //从后往前遍历移位
    for (int i = nums.length-2; i >= 0; i--) {
        nums[i+1] = nums[i];
    }

    //将保存的temp写进数组首部
    nums[0] = temp;
}

解法2

使用新的数组直接将原数组的数据循环到其应在的位置

/**
 * 使用新数组求解
 * @param nums
 * @param k
 */
public void rRotate(int[] nums,int k){
    k = k % nums.length;

    //定义新数组
    int[] arr = new int[nums.length];

    //将原数组的数据放置在新数组旋转后的位置
    for (int i = 0; i < nums.length; i++) {
        arr[(i+k)%nums.length] = nums[i];
    }

    //赋值给原数组
    for (int i = 0; i < nums.length; i++) {
        nums[i] = arr[i];
    }

    System.out.println(Arrays.toString(nums));
}