数组--LeetCode(python)

最新推荐文章于 2023-06-11 20:59:00 发布

qq_26919935

最新推荐文章于 2023-06-11 20:59:00 发布

阅读量1.8k

点赞数

分类专栏： leetcode Python 文章标签： leetcode python 数组

本文链接：https://blog.csdn.net/qq_26919935/article/details/102845781

版权

乘积最大子序列

给定一个整数数组 nums ，找出一个序列中乘积最大的连续子序列（该序列至少包含一个数）。

示例 1:

输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。
示例 2:

输入: [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。

解法：
第一时间想到的是动态规划，想找当前位置上的乘积最大值，但是发现正负号的问题，即前一个位置上乘积最小值乘以当前位置上的数，可能会变成乘积最大值。
也就是两个dp数组，简化一下存储空间的话，就是两个值：前一个位置上的乘积最大值和乘积最小值。
每有一个新的数字加入，最大值要么是当前最大值*新数，要么是当前最小值（负数）*新数（负数），要么是新值。

class Solution(object):
    def maxProduct(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        cur_min = cur_max = res = nums[0]
        
        for i in range(1, len(nums)):
            tmp_max = max(max(cur_min * nums[i], cur_max * nums[i]), nums[i])
            tmp_min = min(min(cur_min * nums[i], cur_max * nums[i]), nums[i])
            
            cur_min = tmp_min
            cur_max = tmp_max
            if cur_max > res:
                res = cur_max
                
        return res

魔术索引

魔术索引。在数组A[0…n-1]中，有所谓的魔术索引，满足条件A[i] = i。给定一个有序整数数组，编写一种方法找出魔术索引，若有的话，在数组A中找出一个魔术索引，如果没有，则返回-1。若有多个魔术索引，返回索引值最小的一个。

示例1:

输入：nums = [0, 2, 3, 4, 5]
输出：0
说明: 0下标的元素为0
示例2:

输入：nums = [1, 1, 1]
输出：1
说明:

nums长度在[1, 1000000]之间
此题为原书中的 Follow-up，即数组中可能包含重复元素的版本

解法

暴力法：从左到右依次遍历即可，O(N)
如果没有重复元素的话，可以直接按照二分法
跳跃法：如果当前值大于i的话，就可以从当前位置继续遍历

class Solution(object):
    def findMagicIndex(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if not nums:
            return -1
        i = 0
        while i < len(nums):
            if nums[i] > i:
                i = nums[i]
            elif nums[i] == i:
                return i
            else:
                i += 1
        return -1

旋转数组

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

示例 1:

输入: [1,2,3,4,5,6,7] 和 k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]
示例 2:

输入: [-1,-100,3,99] 和 k = 2
输出: [3,99,-1,-100]
解释:
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]
说明:

尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
要求使用空间复杂度为 O(1) 的原地算法。

解法：

每次将整个数组向右移动一步，移动k次即可
运用python数组自带的切片方法，非常简单：nums[:]=nums[length-k:] + nums[:length-k]
经过3次子数组的 “对称翻折”：如 [1,2,3,4,5,6,7] 和 k = 3，第一步[1,2,3,4]->[4,3,2,1]，第二步[5,6,7]->[7,6,5]，最后[4,3,2,1,7,6,5]->[5,6,7,1,2,3,4]。
从第一个元素开始进行旋转，逐个将旋转位置上的元素移到下一个位置，直到旋转到该元素的初始位置。同时使用一个变量记录被旋转的元素数量，显然完成所有旋转后旋转元素数量应该是数组长度。（比较麻烦）

注意：

k要对len求一下余
不知道为什么不能直接nums = list(reversed(nums))，可能是编辑器设置的问题，不过可以通过加上":"实现相同的功能

第三种解法：

class Solution(object):
    def rotate(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        
        k = k % len(nums)
        pos = len(nums) - k
        nums[:pos] = list(reversed(nums[:pos]))
        nums[pos:] = list(reversed(nums[pos:]))
        nums[:] = list(reversed(nums[:]))

第四种解法：

class Solution:
    def rotate(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        if len(nums)>1:
            length = len(nums)
            k = k%length
            if k>0:
                move_num = 0
                move_pos = 0
                move_value = nums[move_pos]
                while move_num<length:
                    next_pos = (move_pos+k)%length                    
                    while next_pos!=move_pos:
                        save_value = nums[next_pos]
                        nums[next_pos] = move_value
                        move_value = save_value
                        next_pos=(next_pos+k)%length
                        move_num+=1
                    nums[move_pos]=move_value
                    move_num+=1
                    move_pos+=1
                    move_value = nums[move_pos]

移动零

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

示例:

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:

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

解法：

自己想的一个，用index(0)判断最左边的0的位置是否已经是最后了，如果不是，就把0后面的所有内容往前移一个位置。总的看来，就是冒泡排序的加强版
其实可以不需要管中间移动的过程，只关注最终的结果即可。只要把数组中所有的非零元素，按顺序给数组的前段元素位赋值，剩下的全部直接赋值0就可以。

class Solution(object):
    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        if 0 not in nums:
            return nums
        right = len(nums)
        while nums.index(0) != right:
            pos = nums.index(0)
            nums[pos:right-1] = nums[pos+1:right]
            nums[right-1] = 0
            right -= 1

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

移除元素

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

示例 1:

给定 nums = [3,2,2,3], val = 3,
函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
你不需要考虑数组中超出新长度后面的元素。

示例 2:
给定 nums = [0,1,2,2,3,0,4,2], val = 2,
函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
注意这五个元素可为任意顺序。

你不需要考虑数组中超出新长度后面的元素。

解法
同上

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        i, j = 0, 0
        while j < len(nums):
            if nums[j] != val:
                nums[i] = nums[j]
                i += 1
            j += 1
            
        return i

删除排序数组中的重复项

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。

示例 2:

给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
你不需要考虑数组中超出新长度后面的元素。

解法
上面题目的变形，同样还是用两个指针，i和j来操作，只不过这个时候不是判断j位置是否是val了，而是判断是否和i前面的数相等。

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        i, j = 0, 0
        while j < len(nums):
            if j == 0 or nums[j] != nums[i - 1]:
                nums[i] = nums[j]
                i += 1
            j += 1
            
        return i

删除排序数组中的重复项 II

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素最多出现两次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定 nums = [1,1,1,2,2,3],

函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。

你不需要考虑数组中超出新长度后面的元素。

解法
同上，只需要稍作修改，和i-2的位置比较就可以了。因为它是排序的

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        i, j = 0, 0
        while j < len(nums):
            if j == 0 or j == 1 or nums[j] != nums[i - 2]:
                nums[i] = nums[j]
                i += 1
            j += 1
            
        return i

打乱数组

打乱一个没有重复元素的数组。

示例:

// 以数字集合 1, 2 和 3 初始化数组。
int[] nums = {1,2,3};
Solution solution = new Solution(nums);

// 打乱数组 [1,2,3] 并返回结果。任何 [1,2,3]的排列返回的概率应该相同。
solution.shuffle();

// 重设数组到它的初始状态[1,2,3]。
solution.reset();

// 随机返回数组[1,2,3]打乱后的结果。
solution.shuffle();

解法：
注意这里的随机要用洗牌方法：在每次迭代中，生成一个范围在当前下标到数组末尾元素下标之间的随机整数。接下来，将当前元素和随机选出的下标所指的元素互相交换。注意，当前元素是可以和它本身互相交换的 - 否则生成最后的排列组合的概率就不对了。
注意randint(min, max)的用法，min和max的值都可能被取到的。
init的时候保存两个，否则shuffle后就变化了原始数组
不明白： self.ori必须在self.arr前面定义，而且必须是nums[:]，是内部存储的一些问题么？如果定义的是self.ori = nums，修改arr的时候会把nums修改，进而把ori修改了。

import random

class Solution(object):

    def __init__(self, nums):
        """
        :type nums: List[int]
        """
        self.ori = nums[:]
        self.arr = nums
        

    def reset(self):
        """
        Resets the array to its original configuration and return it.
        :rtype: List[int]
        """
        return self.ori
        

    def shuffle(self):
        """
        Returns a random shuffling of the array.
        :rtype: List[int]
        """
        for i in range(len(self.arr)):
            j = random.randint(i, len(self.arr)-1)
            self.arr[i], self.arr[j] = self.arr[j], self.arr[i]
            
        return self.arr


# Your Solution object will be instantiated and called as such:
# obj = Solution(nums)
# param_1 = obj.reset()
# param_2 = obj.shuffle()

递增的三元子序列

给定一个未排序的数组，判断这个数组中是否存在长度为 3 的递增子序列。

数学表达式如下:

如果存在这样的 i, j, k, 且满足 0 ≤ i < j < k ≤ n-1，
使得 arr[i] < arr[j] < arr[k] ，返回 true ; 否则返回 false 。
说明: 要求算法的时间复杂度为 O(n)，空间复杂度为 O(1) 。

示例 1:

输入: [1,2,3,4,5]
输出: true
示例 2:

输入: [5,4,3,2,1]
输出: false

解法：
注意是递增的子序列，并没有说是“连续”子序列，但是还是走动态规划的思路，保存两个指针，一个min，一个medium；
一种方式是把min和medium初始化为最大值：float(“inf”)
另一种是设置一个flag标记下medium是否已经被初始化了。
因此遍历一遍数组，随时更新min和Medium的值，一旦遍历到比medium还大的数，直接返回ture

class Solution(object):
    def increasingTriplet(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        if not nums:
            return False
        
        mi = nums[0]
        flag = 0
        
        for i in range(1, len(nums)):
            tmp = nums[i]
            if tmp < mi:
                mi = tmp
            elif tmp > mi and (flag == 0 or tmp < me):
                me = tmp
                flag = 1
            elif flag == 1 and tmp > me:
                return True
            
        return False

两个数组的交集 II

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

示例 1:

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

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]
说明：

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

如果给定的数组已经排好序呢？你将如何优化你的算法？
如果 nums1 的大小比 nums2 小很多，哪种方法更优？
如果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

解法：

最简单的方法就是遍历两个数组，遇到相同的就记录下来，并删除掉该元素，避免重复。
先给两个数组排序，使用归并排序的思路。遇到两个数组的情况，如果要加速处理，就要想到可以设置两个指针。
用dict存储元素

解法1：

class Solution(object):
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        res = []
        for idx, x in enumerate(nums1):
            if x in nums2:
                res.append(x)
                nums2.remove(x)
                
        return res

解法2：

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        res = []
        nums1 = sorted(nums1)
        nums2 = sorted(nums2)
        
        i = 0
        j = 0
        while i < len(nums1) and j < len(nums2):
            if nums1[i] > nums2[j]:
                j += 1
            elif nums1[i] < nums2[j]:
                i += 1
            else:
                res.append(nums1[i])
                i += 1
                j += 1
                
                
        return res

解法3：

class Solution:
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """

        m = len(nums1)
        n = len(nums2)

        if m == 0 or n == 0:
            return []


        dicts = {
   }
        for i in nums1:
            if i in dicts:
                dicts[i] += 1
            else:
                dicts[i] = 1

        ret = []
        for j in nums2:
            if j in dicts and dicts[j] > 0:
                ret.append(j)
                dicts[j] -= 1

        return ret

除自身以外数组的乘积

给定长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。

示例:

输入: [1,2,3,4]
输出: [24,12,8,6]
说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。

进阶：
你可以在常数空间复杂度内完成这个题目吗？（出于对空间复杂度分析的目的，输出数组不被视为额外空间。）

解法：
最简单的思路就是用除法或者O(n^2)的遍历，但是都被禁止了
其实想到用两个指针了，但是没想到用两个数组
因为是乘法，满足交换律，所以可以在第一遍遍历的时候把nums[i]左边部分的乘积存下来，第二遍的时候把右边的存下来，最后对应相乘就可以。（注意O(kn)=O(n)）
但是要在常熟空间复杂度的话，就只能保留一个数组，可以选择保留左边数组，右边的用一个数值代替就可以了，因为每次用完就不用了。

遍历nums，在遍历的过程中将对应元素累乘，例如
1  2  3  4
1  1  2  6
这样我们就得到了对应元素左边所有元素的乘积。然后我们反向遍历nums，做相同操作即可。
1  2  3  4
24 12 4  1
再将两个结果相乘即可。
1  2  3  4
24 12 8  6

Code

class Solution(object):
    def productExceptSelf(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        left = [1] * len(nums)
        right = 1
        
        for i in range(1, len(nums)):
            left[i] = left[i-1] * nums[i-1]
            
        for i in range(len(nums

最低0.47元/天解锁文章

qq_26919935

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数组--LeetCode(python)

乘积最大子序列给定一个整数数组 nums ，找出一个序列中乘积最大的连续子序列（该序列至少包含一个数）。示例 1:输入: [2,3,-2,4]输出: 6解释: 子数组 [2,3] 有最大乘积 6。示例 2:输入: [-2,0,-1]输出: 0解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。解法：第一时间想到的是动态规划，想找当前位置上的乘积最大值，但是发现正负号的...
复制链接

扫一扫