数组与矩阵

1. 把数组中的0移到末尾

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。

将非0元素按读取顺序放在数组的前面，剩下的位置全放0。

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        index = 0
        for num in nums:
            if num != 0:
                nums[index] = num
                index += 1
        while index < len(nums):
            nums[index] = 0
            index += 1

2. 改变矩阵维度

给出一个由二维数组表示的矩阵，以及两个正整数r和c，分别表示想要的重构的矩阵的行数和列数。

重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。

如果具有给定参数的reshape操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。

输入: 
nums = 
[[1,2],
 [3,4]]
r = 1, c = 4

输出: [[1,2,3,4]]
解释:行遍历nums的结果是 [1,2,3,4]。新的矩阵是 1 * 4 矩阵, 用之前的元素值一行一行填充新矩阵。

class Solution:
    def matrixReshape(self, nums: List[List[int]], r: int, c: int) -> List[List[int]]:
        m, n = len(nums), len(nums[0])
        if m * n != r * c:
            return nums

        reshape_nums = [[0 for _ in range(c)] for _ in range(r)]
        index = 0
        for i in range(r):
            for j in range(c):
                reshape_nums[i][j] = nums[index // n][index % n]
                index += 1
        return reshape_nums

3. 找出数组中最长的连续 1

给定一个二进制数组， 计算其中最大连续1的个数。

示例 1:

输入: [1,1,0,1,1,1]
输出: 3
解释: 开头的两位和最后的三位都是连续1，所以最大连续1的个数是 3.

class Solution:
    def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
        max_ = 0
        cur = 0
        for num in nums:
            cur = 0 if num == 0 else cur + 1
            max_ = max(max_, cur)
        return max_

4. 有序矩阵查找

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：

每行的元素从左到右升序排列。
每列的元素从上到下升序排列。

现有矩阵 matrix 如下：
[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。

给定 target = 20，返回 false。

从右上角开始：

class Solution:
    def searchMatrix(self, matrix, target):
        """
        :type matrix: List[List[int]]
        :type target: int
        :rtype: bool
        """
        if not matrix or len(matrix) == 0 or len(matrix[0]) == 0:
            return False
        m = len(matrix)
        n = len(matrix[0])
        row = 0
        col = n - 1
        while row < m and col >= 0:
            if target == matrix[row][col]: 
                return True
            elif target < matrix[row][col]:
                col -= 1
            else:
                row += 1
        return False

5. 有序矩阵的 Kth Element

给定一个 n x n 矩阵，其中每行和每列元素均按升序排序，找到矩阵中第 k 小的元素。
请注意，它是排序后的第 k 小元素，而不是第 k 个不同的元素。

matrix = [
   [ 1,  5,  9],
   [10, 11, 13],
   [12, 13, 15]
],
k = 8,

返回 13。

二分查找：利用数组中的最小值和最大值作为边界点，计算其中值，循环得到数组中小于中值得个数

class Solution:
    def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
        m, n = len(matrix), len(matrix[0])
        lo, hi = matrix[0][0], matrix[m - 1][n - 1]
        while lo <= hi:
            mid = lo + (hi - lo) // 2
            cnt = 0
            for i in range(m):
                for j in range(n):
                    if matrix[i][j] <= mid:
                        cnt += 1
            if cnt < k:
                lo = mid + 1
            else:
                hi = mid - 1
        return lo

6. 一个数组元素在 [1, n] 之间，其中一个数被替换为另一个数，找出重复的数和丢失的数

集合 S 包含从1到 n 的整数。不幸的是，因为数据错误，导致集合里面某一个元素复制了成了集合里面的另外一个元素的值，导致集合丢失了一个整数并且有一个元素重复。

给定一个数组 nums 代表了集合 S 发生错误后的结果。你的任务是首先寻找到重复出现的整数，再找到丢失的整数，将它们以数组的形式返回。

输入: nums = [1,2,2,4]
输出: [2,3]

将 nums 中的元素 - 1 找到此元素对应的下标，并将此下标上的元素变为负数，依次循环数组，直到数组中某一元素对应的下标为负数，说明此数为重复的数。

数组中为正整数的数对应的下标 + 1 即为缺失的数。

class Solution:
    def findErrorNums(self, nums):
        n = len(nums)
        dup = -1
        for i in range(n):
            index = abs(nums[i]) - 1
            if nums[index] < 0:
                dup = abs(nums[i])
            else:
                nums[index] *= -1

        missing = -1
        for i in range(n):
            if nums[i] > 0:
                missing = i + 1
        return [dup, missing]

最直接的方法是先对数组进行排序，这种方法时间复杂度为 O(NlogN)。本题可以以 O(N) 的时间复杂度、O(1) 空间复杂度来求解。

主要思想是通过交换数组元素，使得数组上的元素在正确的位置上。

class Solution:
    def findErrorNums(self, nums):
        def swap(nums, i, j):
            temp = nums[i]
            nums[i] = nums[j]
            nums[j] = temp
		
        # 相当于给数组排序
        for i in range(len(nums)):
            # 数组中的元素不为 位置+1，并且此元素位置的数组不为此元素，则交换
            while nums[i] != i + 1 and nums[nums[i] - 1] != nums[i]:
                swap(nums, i, nums[i] - 1)

        for i in range(len(nums)):
            if nums[i] != i + 1:
                return [nums[i], i + 1]
        return None

7. 找出数组中重复的数，数组值在 [1, n] 之间

给定一个包含 n + 1 个整数的数组 nums，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个重复的整数。假设只有一个重复的整数，找出这个重复的数。

s输入: [1,3,4,2,2]
输出: 2

要求不能修改数组，也不能使用额外的空间。

二分查找解法：

class Solution:
    def findDuplicate(self, nums: List[int]) -> int:
        l = 1
        h = len(nums) - 1
        while l <= h:
            mid = l + (h - l) // 2
            cnt = 0
            for i in range(len(nums)):
                if nums[i] <= mid:
                    cnt += 1
            if cnt > mid:
                h = mid - 1
            else:
                l = mid + 1
        return l

双指针解法，类似于有环链表中找出环的入口：

class Solution:
    def findDuplicate(self, nums: List[int]) -> int:
        slow = nums[0] 
        fast = nums[nums[0]]
        while slow != fast:
            slow = nums[slow]
            fast = nums[nums[fast]]
        fast = 0
        while slow != fast:
            slow = nums[slow]
            fast = nums[fast]
        return slow