LeeCode算法Day2 | 数组：977.有序数组的平方 、209.长度最小的子数组、 59.螺旋矩阵II

977. 有序数组的平方

题目链接：977.有序数组的平方

方法一：暴力搜索

class Solution(object):
    def sortedSquares(self, nums):
        l = len(nums)
        res = [nums[i] * nums[i] for i in range(l)]
        res.sort()
        return res


nums = [-4,-1,0,3,10]
target = 2
solution = Solution()
print(solution.sortedSquares(nums))

方法二：指针法

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        l = len(nums)
        i = 0
        j = l - 1
        k = l - 1
        nums_new = [0 for i in range(l)]
        while k >= 0:
            if nums[i] * nums[i] >= nums[j] * nums[j]:
                nums_new[k] = nums[i] * nums[i]
                i += 1
            else:
                nums_new[k] = nums[j] * nums[j]
                j -= 1
            k -= 1
        return nums_new


nums = [-4,-1,0,3,10]
target = 2
solution = Solution()
print(solution.sortedSquares(nums))

注意：

1.创建一个新数组：

#一维列表的创建：
    a = [None] * n  # 创建一个初值为None的长度为n的列表a,None只是一种初值也可换成其他的初值。
# 二维列表的创建：
    a = [[0 for col in range(m)] for row in range(n)]  # 创建一个n*m的二维矩阵a，每个初值都是0

注意不要用下面这个！

nums_new = nums

在Python中，当你使用 nums_new = nums 时，实际上是将 nums_new 变量指向了和 nums 相同的列表对象，而不是创建了一个新的列表对象。这意味着当你修改 nums_new 时，nums 也会被修改，因为它们指向同一个列表对象。

209. 长度最小子数组

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        left = 0
        right = 0
        cur_sum = 0
        min_len = float('inf')
        l = len(nums)
        while right < l:
            cur_sum += nums[right]
            while cur_sum >= target:
                cur_sum -= nums[left]
                min_len = min(min_len, (right - left + 1))
                left += 1

            right += 1
        return min_len if min_len !=  float('inf') else 0

59、螺旋矩阵

class Solution(object):
    def array(self, n):
        nums = [[0]*n for _ in range(n)]
        startx = 0
        starty = 0
        count = 1
        loop = n // 2
        mid = n // 2
        offset = 1
        for iloop in range(loop):
            for j in range(starty, n - offset):
                nums[startx][j] = count
                count += 1
            for i in range(startx, n - offset):
                nums[i][n - offset] = count
                count += 1
            for j in range(n - offset, starty, -1):
                nums[n - offset][j] = count
                count += 1
            for i in range(n - offset, startx, -1):
                nums[i][starty] = count
                count += 1
            offset += 1  # 别忘了这三个加一
            startx += 1
            starty += 1
        if n % 2 == 1:
            nums[mid][mid] = count
        return nums


n = 3
solution = Solution()
print(solution.array(n))

注意：

1.在Python中，对于矩阵的索引方式在列表（list）和数组（array）之间有所不同。

1. 列表（list）：

   • 对于列表来说，通常使用嵌套列表表示矩阵，其中每个子列表表示矩阵的一行。因此，要访问矩阵中的某个元素，你需要使用两次索引，一次用于行，一次用于列。例如，my_matrix[i][j] 表示访问矩阵中第 i 行第 j 列的元素。

2. 数组（array）：

   • 对于NumPy数组，它提供了更加简洁和高效的索引方式。你可以直接使用逗号分隔的整数索引来访问数组的元素。例如，my_array[i, j] 表示访问数组中第 i 行第 j 列的元素。
   • 此外，NumPy数组还支持切片、布尔索引和花式索引等更高级的索引方式，使得对矩阵的操作更加灵活和高效。

总的来说，虽然列表和数组都可以表示矩阵，但是使用数组（特别是NumPy数组）来操作矩阵更加方便和高效，因为NumPy提供了丰富的索引和操作工具。