Leetcode1数组练习

66：plus one

代码部分1

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        l=[1]
        c=0
        if len(digits)==0:
            return digits
        cur=len(digits)-1
        while cur+1:
            if digits[cur]==9:
                d1=digits[cur+1:]
                digits=digits[:cur]
                digits.append(0)
                digits.extend(d1)
                cur-=1
                c=1
            else:
                digits[cur]+=1
                cur=-2
                break
        if cur==0 or cur==-1:
            l.extend(digits)
            digits=l
        return digits

**主要思路：**想法比较简单，当发现cur位置为9时截取长度[：cur]以及[cur+1:]，cur位置处置为0

Runtime: 36 ms, faster than 88.65% of Python3
Memory Usage: 12.9 MB, less than 98.54%

代码部分2

        if len(digits) == 0:
            digits = [1]
        elif digits[-1] == 9:
            digits = self.plusOne(digits[:-1])
            digits.extend([0])
        else:
            digits[-1] += 1
        return digits

Runtime: 36 ms, faster than 88.65% of Python3
Memory Usage: 13.2 MB, less than 57.36% of Python3

递归的方式：
优点：代码简洁漂亮
缺点：空间复杂度会稍微大一点点

31. Next Permutation

题意理解

本题目标：输入一个list，求取该list的各个数字的各种排列组合的情况下仅大于本list的下一种组合方式
思路：list从后往前查找当nums[i-1]<nums[i]时，锁定从i位置起是需要重新排列的部分，并且需要寻找nums[i:]中大于nums[i-1]的最小值并与之交换

代码部分

class Solution:
    def nextPermutation(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        c=1
        for i in range(len(nums)-1,0,-1):
            if nums[i-1] < nums[i]:
                vol=max(nums[i:])
                cur=i
                for j in range(i,len(nums)):
                    if nums[j]>nums[i-1] and nums[j]<vol:
                        vol=nums[j]
                        cur=j
                nums[i-1],nums[cur] = nums[cur],nums[i-1]
                nums[i:]=sorted(nums[i:])
                c=0
                break
        if c:nums.sort()

Runtime: 36 ms, faster than 97.38% of Python3

Memory Usage: 13.1 MB, less than 78.38%

评价：方法不难，重在理解如何寻找仅大于本轮list的下一轮排列组合方式