leetcode算法入门day2——双指针

第一题 轮转数组189

**@Date 2022年1月15日
给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

示例 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]**

package day2双指针;

import java.util.Arrays;

public class 轮转数组189 {
	public static void main(String[] args) {
		int [] num = {-1};
		rotate(num, 2);
	}
	public static 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 static void reverse(int[] nums,int start,int end) {
		int temp;
		while(start<end) {
			temp = nums[start];
			nums[start] = nums[end];
			nums[end] = temp;
			start++;
			end--;
		}
	}
		/*方法一：
		 * 使用额外的数组我们可以使用额外的数组来将每个元素放至正确的位置。用 nn 表示数组的长度，我们遍历原数组，
		将原数组下标为 ii 的元素放至新数组下标为 (i+k)\bmod n(i+k)modn 的位置，
		最后将新数组拷贝至原数组即可。
		public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
        参数：
    src:源数组；	srcPos:源数组要复制的起始位置；   dest:目的数组；	destPos:目的数组放置的起始位置；	length:复制的长度。
		 */
		
		/*
		 * 方法二：
		 * 
		 */
		
		
		/*
		 * 方法三：数组翻转
	该方法基于如下的事实：当我们将数组的元素向右移动 kk 次后，尾部 k\bmod nkmodn 个元素会移动至数组头部，
	其余元素向后移动 k\bmod nkmodn 个位置。该方法为数组的翻转：我们可以先将所有元素翻转，
	这样尾部的 k\bmod nkmodn 个元素就被移至数组头部，然后我们再翻转 [0, k\bmod n-1][0,kmodn−1] 
	区间的元素和 [k\bmod n, n-1][kmodn,n−1] 区间的元素即能得到最后的答案。
		 */

//		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;
//	        }
//	    }
		
		
		
//		int[] result = new int[nums.length];
//		result = Arrays.copyOf(nums,nums.length);
//		if (nums.length == 1||k>nums.length) {
//			for (int i = 0; i < nums.length; i++) {
//				System.out.print(nums[i]);
//			}
//		}
//		for (int i = 0; i < k; i++) {
//			result[i] = nums[nums.length + i - k];
//		}
//		for (int i = k; i < nums.length; i++) {
//			result[i] = nums[i-k];
//		}
//		for (int i = 0; i < result.length; i++) {
//			nums[i] = result[i];
//			System.out.print(nums[i]);
//		}
}

第二题 有序数组的平方977

@Date 2022年1月15日
给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

package day2双指针;

import java.util.Arrays;

public class 有序数组的平方977 {
	public int[] sortedSquares(int[] nums) {
		//1.暴力求解
//		int [] copy = nums;
//		for (int i = 0; i < nums.length; i++) {
//			copy[i] = (int) Math.pow(nums[i],2);
//		}
//		Arrays.sort(copy);
//		return copy;
		
		
		
		
		//2.双指针方法1
		/*
		 * 同样地，我们可以使用两个指针分别指向位置 00 和 n-1n−1，每次比较两个指针对应的数，
		 * 选择较大的那个逆序放入答案并移动指针。这种方法无需处理某一指针移动至边界的情况。
		 */
		// 左指针，指向原数组最左边
        int left = 0;
        // 有指针，指向原数组最右边
        int right = nums.length - 1;
        // 创建一个新数组，存储平方值
        int[] result = new int[nums.length];
        // 得到元素值平方值，从新数组最后位置开始写
        int write = nums.length - 1;
        // 左右指针相遇（逐渐靠拢的过程）之后不再循环
        while (left <= right){
            // 如果原数组的左指针对应的平方值大于右指针，那么往新数组最后位置写入左指针对应的平方值
            if (nums[left] * nums[left] > nums[right] * nums[right]){
                result[write] = nums[left] * nums[left];
                // 左指针右移
                left ++;
                // 移动新数组待写入的位置
                write --;
            }
            else {
                result[write] = nums[right] * nums[right];
                right --;
                write --;
            }
        }
        return result;

    }
}