数据结构与算法--数组

数组

数组是存放在连续内存空间上的相同类型数据的集合。
数组下标从0开始；数组内存空间的地址是连续的。
数组的元素是不能删除的，只能覆盖。

二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

注：当数组为有序数组且无重复元素时，可以利用二分查找法返回目标元素的下标。此外二分查找涉及到边界条件，要清楚区间的定义。

# 输入 nums = [-1,0,3,5,9,12], target = 9 
# 输出 4
def solution(nums, target):
	n = len(nums)
	left = 0
	right = n - 1
	while left <= right:
		mid = left + (right - left) // 2
		if nums[mid] == target:
			return mid
		elif nums[mid] > target:
			right = mid - 1
		else:
			left = mid + 1 
	return -1

移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组

# nums = [0,1,2,2,3,0,4,2], val = 2

def solution(nums, val):
	fast = slow = 0
	n = len(nums)
	while fast < n:
		if nums[fast] != val:
			nums[slow] = nums[fast]
			slow += 1
		fast += 1
	return slow

有序数组的平方

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

# 输入nums = [-4,-1,0,3,10]
# 输出 [0,1,9,16,100]

def solution(nums):
	n = len(nums)
	l = 0
	r = n -1
	k= n - 1
	res = [0] * n
	while l <= r:
		lm = nums[l] ** 2
		rm = nums[r] ** 2
		if lm > rm:
			res[k] = lm
			l += 1
		else:
			res[k] = rm
			r -= 1
		k -= 1
	return res

长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

# 输入：s = 7, nums = [2,3,1,2,4,3]
# 输出：2

def solution(nums, s):
	res = float('inf')
	sum_num = 0
	index = 0
	for i in range(len(nums)):
		sum_num += nums[i]
		while sum_num >= s:
			res = min(res, i-index+1)
			sum_num -= nums[index]
			index += 1
	return 0 if res == float('inf') else res

螺旋矩阵II

给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

# 输入: 3
# 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

def solution(n):
	dp = [[0] * n for _ in range(n)]
	left, right, up, down = 0, n-1, 0, n-1
	number = 1
	while left < right and up < down:
		for x in range(left, right):
			dp[up][x] = number
			number += 1
		for y in range(up, down):
			dp[y][right] = number
			number += 1
		for x in range(right, left, -1):
			dp[down][x] = number
			number += 1
		for y in range(down, up, -1):
			dp[y][left] = number
			number
		left += 1
		right -= 1
		up += 1
		down -= 1
	if n % 2 == 1:
		dp[n // 2][n // 2] = number
	return dp