day02 有序数组平方、长度最小的子数组、螺旋矩阵II

题目链接:leetcode977-有序数组平方,leetcode209-长度最小的子数组, leetcode59-螺旋矩阵II

有序数组平方

解题思路:双指针法,left, right
1)创建一个等长的新数组
2)left从左到右扫描数组,right从右向左扫描数组
3)分别对left和right进行平方,并对平方的结果进行比较,谁大谁放入新数组(从新数组尾部开始存放,因为原始数组是从小到大排序的,如果存在负数,则left执行的val的平方值可能会大于right指向的平方值)
时间复杂度: O(n)
空间复杂度: O(1): 除了存储答案的数组以外,只需要维护常量空间

Go

func sortedSquares(nums []int) []int {
	numsLen := len(nums)
	left, right := 0, numsLen-1

	// 创建新数组
	ans := make([]int, numsLen)
	ansIdx := numsLen - 1

	for left <= right {
		lS, rS := nums[left]*nums[left], nums[right]*nums[right]
		if lS >= rS {
			ans[ansIdx] = lS
			left++
		} else {
			ans[ansIdx] = rS
			right--
		}
		ansIdx--
	}
	return ans
}

Rust

	pub fn sorted_squares(nums: Vec<i32>) -> Vec<i32> {
		let (mut left, mut right) = (0usize, nums.len() - 1);
		let mut ans = vec![0;nums.len()];
		let mut ans_idx = right;

		while left <= right {
			let (l_s, r_s) = (nums[left] * nums[left], nums[right] * nums[right]);
			// 之所以使用l_s >= r_s, 是为了避免 right-=1(right为0时会报错)
			// 如:[0, 1, 2, 3], right最小也只是为0, 此时(left=right=0)
			if l_s >= r_s {
				ans[ans_idx] = l_s;
				left += 1;
			} else {
				ans[ans_idx] = r_s;
				right -= 1;
			}

			// ans_idx是usize类型
			if ans_idx == 0 {
				break
			}

			ans_idx -=1;

		}

		ans
	}

长度最小的子数组

解题思路:滑动窗口,双指针: l,r
1) 找到sum>=target的连续子数组,确保[l, r]范围内的val的sum>=target, r-l+1即为sum>=target的连续子数组的长度
2)移动l, 在满足sum >= target的前提下,缩小[l, r]的范围,持续移动l, 求最小的r-l+1
时间复杂度: O(n)
空间复杂度: O(1)

Go

func minSubArrayLen(target int, nums []int) int {
	l, r, numsLen := 0, 0, len(nums)
	minLen := numsLen + 1 // 设置初始长度为最大长度
	sum := 0

	for ; r < numsLen; r++ {
		sum += nums[r]

		for sum >= target {
			curLen := r - l + 1
			if curLen < minLen {
				minLen = curLen
			}
			
			// 缩小[l, r]的范围
			sum -= nums[l]
			l++
		}
	}

	// minLen等于numsLen+1说明没有发生任何变化,即没有找到minLen
	if minLen == numsLen+1 {
		return 0
	}

	return minLen
}

Rust

	pub fn min_sub_array_len(target: i32, nums: Vec<i32>) -> i32 {
		// 给min_len一个默认大小
		let (mut l, mut min_len,mut sum)  = (0usize, nums.len()+1, 0);

		for r in 0..nums.len() {
			sum += nums[r];
			// 在满足sum >= target的前提下,缩小[l, r]的范围
			while sum >= target {
				let cur_len = r - l + 1;
				if cur_len < min_len {
					min_len = cur_len;
				}

				// 移动l
				sum -= nums[l];
				l += 1;
			}

		}

		// min_len 等于默认值,说明min_len没有发生变化,说明没有找到最小连续子数组
		if min_len == nums.len() + 1 {
			return 0;
		}
		min_len as i32
	}

螺旋矩阵II

解题思路:模拟题,画图思考

Go

func generateMatrix(n int) [][]int {
	// cycleNum: 要转的圈数
	// lineNo: 行号
	// columnNo: 列号
	// layerNo: 当前层数
	cycleNum, lineNo, columnNo, layerNo := n/2, 0, 0, 1

	// 初始化矩阵
	matrix := make([][]int, n)
	for i := 0; i < n; i++ {
		matrix[i] = make([]int, n)
	}

	// 计数器,每经过一个格子进行累加
	counter := 1

	for i := 0; i < cycleNum; i++ {
		// 左-->右,行不变,列累加
		for columnNo < n-layerNo {
			matrix[lineNo][columnNo] = counter
			counter++
			columnNo++
		}

		// 上--->下,列不变,行累加
		for lineNo < n-layerNo {
			matrix[lineNo][columnNo] = counter
			counter++
			lineNo++
		}

		// 右--->左, 行不变,列减小
		for columnNo >= layerNo {
			matrix[lineNo][columnNo] = counter
			counter++
			columnNo--
		}

		// 下--->上,列不变,行减小
		for lineNo >= layerNo {
			matrix[lineNo][columnNo] = counter
			counter++
			lineNo--
		}

		// 此时lineNo和columnNo都等于layerNum-1
		layerNo++
		lineNo++
		columnNo++

	}

	// 如果n为奇数,则最中心会空出来,即matrix[n/2][n/2]=n^2
	if n&1 == 1 {
		matrix[n/2][n/2] = n * n
	}

	return matrix
}

Rust

pub fn generate_matrix(n: i32) -> Vec<Vec<i32>> {
		// cycle_num: 要转的圈数
		// line_no:行的标号
		// column_no: 列的标号
		// layer_no: 当前在第几层
		let n_usize = n as usize;
		let (cycle_num, mut layer_no) = (n/2, 1usize);
		let (mut line_no, mut column_no) = (0usize, 0usize);

		// 累加器
		let mut counter = 1;

		// 初始化矩阵
		let mut matrix = vec![vec![0;n as usize];n as usize];

		for i in 0..cycle_num {
			// 左--->右,行不变,列累加
			while column_no < n_usize - layer_no {
				matrix[line_no][column_no] = counter;
				counter += 1;
				column_no += 1;
			}

			// 上--->下,列不变,行累加
			while line_no < n_usize - layer_no {
				matrix[line_no][column_no] = counter;
				counter += 1;
				line_no += 1;
			}

			// 右--->左,行不变,列减小
			while column_no >= layer_no {
				matrix[line_no][column_no] = counter;
				counter += 1;
				column_no -= 1;
			}

			// 下--->上,列不变,行减小
			while line_no >= layer_no {
				matrix[line_no][column_no] = counter;
				counter += 1;
				line_no -= 1;
			}

			// 此时 line_no和column_no都为 layer_no-1

			// 等待进入下一层
			layer_no += 1;
			line_no += 1;
			column_no += 1;
		}

		if n & 1 == 1 {
			matrix[n_usize >> 1][n_usize >> 1] = n * n;
		}
		matrix
	}

你可能感兴趣的:(算法)