python 数组 相关算法题 (基础二)

题目：力扣

1. 求两个数组的交集

给定两个数组，编写一个函数来计算它们的交集

说明：

输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。
我们可以不考虑输出结果的顺序。

"""
例1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

例2：
输入：nums1 = [1,2,2,1], nums2 = [2]
输出：[2]

例3：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]
"""

def find_sample(nums1, nums2):
    d =[]
    for i in nums1:
        if i not in nums2:
            continue
        else:
            d.append(i)
            # 如果不remove会重复判断，当nums1[1, 2, 2, 1], nums2[2] 不remove时结果是[2, 2],是错误的，remove之后应该返回[2]
            nums2.remove(i) 
    return d


def find_sample(nums1, nums2):
    nums1 = sorted(nums1)
    return [nums1.pop(nums1.index(i)) for i in nums2 if i in nums1]


# 速度最快
def find_sample(nums1, nums2): 
    import collections
    nums1 = collections.Counter(num1)
    nums2 = collections.Counter(num2)
    nums = nums1 & nums2
    return list(nums.elements())

官方的解答： 排序+双指针

将两个数组进行排序，随后用双指针顺序查找相同的元素
时间复杂度：O(max(nlogn, mlogm, n+m))
空间复杂度：O(1)
(nn,mm 分别为两个数组的长度)
如果是进阶问题一中已排序的数组，则只需 O(n)的时间复杂度

def intersect(nums1, nums2):
        nums1.sort()
        nums2.sort()
        r = []
        left, right = 0, 0
        while left < len(nums1) and right < len(nums2):
            if nums1[left] < nums2[right]:
                left += 1
            elif nums1[left] == nums2[right]:
                r.append(nums1[left])
                left += 1
                right += 1    
            else:
                right += 1
        return r

2.  数字加一

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。

输入：digits = [1,2,3]   输出：[1,2,4] 

输入：digits = [0]        输出：[1]

输入：digits = [9]        输出：[1，0]

def calcute_li(li):
    return [int(j) for j in str(int(''.join([str(i) for i in li]))+1)]

3. 移动数组中的0

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

输入: [0,1,0,45,12]

输出: [1,45,12,0,0]

1. 必须在原数组上操作，不能拷贝额外的数组。
2. 尽量减少操作次数。

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

def moveZeroes(nums):
    for i in range(len(nums)):
        if nums[i] == 0:
            nums.remove(0)
            nums.append(0)
    return nums

4..两数之和

给定一个整数数组 nums 和一个整数目标值 target，在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标; 每种输入只会对应一个答案; 但是，数组中同一个元素在答案里不能重复出现，可以按任意顺序返回答案

输入： nums = [3, 2, 3, 3 ]     输出：target = 6     返回：2, 0

def two_sum(nums, target):
    res = dict()
    for k, v in enumerate(nums):
        temp = target - v 
        if res.get(temp) is not None:
            return k, res[temp]
        else:
            res[v] = k
    return 0, 0

5. 旋转图像

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

需在原矩阵旋转图像，需要直接修改输入的二维矩阵，不使用另一个矩阵来旋转图像

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[7,4,1],[8,5,2],[9,6,3]]

def rotate_list(matrix):
    j =0 
    for i in zip(*matrix[::-1]):
        li[j] =i
        j+=1
    return matrix

def rotate_list(matrix):
    for k, v in enumerate(zip(*matrix)):
        matrix[k] = list(v)[::-1]
    return matrix

总结：zip()真香，在后续的 字符串中有讲  CSDNhttps://mp.csdn.net/mp_blog/creation/editor/120432337

非zip():

def rotate_list(matrix):
    n = len(matrix)

    for i in range(n//2):
        for j in range((n+1)//2):
            matrix[i][j], matrix[j][n-i-1], matrix[n-i-1][n-j-1], matrix[n-j-1][i]\
            = matrix[n-j-1][i], matrix[i][j], matrix[j][n-i-1], matrix[n-i-1][n-j-1]
    return matrix