Leetcode腾讯算法题 -- 刷 出题指数为3颗星以上的题目 --第二部分

题目一：LT215-数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

思路是 借鉴快速排序的partition。然后如果刚好partition出来的index 右边长度为k-1的话 那么这个位置的数刚好就是要求的topK

class Solution:
    def partition(self,arr,low,high):
        i = low -1
        pivot = arr[high]
        for j in range(low,high):
            if arr[j]<pivot:
                i+=1 
                arr[i],arr[j] = arr[j],arr[i]
        arr[i+1],arr[high] = arr[high],arr[i+1]
        return i+1
          
    #最大K元素。 也就是右边区间的K-1个数比这个数mid大。
    def topK(self,arr,low,high,k):
        L = len(arr)
        if low<high:
            mid = self.partition(arr,low,high)
            #右边区间刚好长度为 K-1，就可以返回了
            if L - mid ==k: return 
            elif L - mid > k: self.topK(arr,mid+1,high,k)
            else: self.topK(arr,low,mid-1,k)
      
    def findKthLargest(self, nums: List[int], k: int) -> int:
        self.topK(nums,0,len(nums)-1,k)
        return nums[-k]

题目二：LT20. 有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合

输入：s = "()[]{}"
输出：true
输入：s = "(]"
输出：false
输入：s = "{[]}"
输出：true

class Solution:
    def isValid(self, s: str) -> bool:
        dic = {'(':')', '[':']', '{':'}','_':'_'}
        stack = ['_']
        for i in range(len(s)):
            if s[i] in dic: stack.append(s[i])
            else:
                tmp = stack.pop()
                if dic[tmp] != s[i]:return False 
        return len(stack)==1

题目三：LT394. 字符串解码

给定一个经过编码的字符串，返回它解码后的字符串。
编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。
你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。
此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入

输入：s = "3[a]2[bc]"
输出："aaabcbc"
输入：s = "3[a2[c]]"
输出："accaccacc"
输入：s = "2[abc]3[cd]ef"
输出："abcabccdcdcdef"

class Solution:
    def decodeString(self, s: str) -> str:
        stack = []
        num = 0
        ans = ''
        for c in s:
            if c == '[':
                stack.append([num, ans])
                num = 0 
                ans = ''
            elif c == ']':
                n , last_s = stack.pop()
                ans = last_s + n*ans 
            elif '0' <= c <='9':
                num =  num*10 + int(c)
                #这是因为100 字符 输入的是 1 -- 0 -- 0 不是直接输入100数字
                #"100[leetcode]"
            else:
                ans += c 
        return ans 

题目四：LT8. 字符串转换整数 (atoi)

请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。
函数 myAtoi(string s) 的算法如下：
读入字符串并丢弃无用的前导空格
检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
将前面步骤读入的这些数字转换为整数（即，“123” -> 123， “0032” -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
如果整数数超过 32 位有符号整数范围 [−231, 231 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为 231 − 1
返回整数作为最终结果

输入：s = "42"
输出：42
输入：s = "   -42"
输出：-42
输入：s = "4193 with words"
输出：4193
输入：s = "words and 987"
输出：0
输入：s = "-91283472332"
输出：-2147483648
由于 -91283472332 小于范围 [-231, 231 - 1] 的下界，最终结果被截断为 -231 = -2147483648

方法一：正则化
正则化的的方式了解一下？

import re 
class Solution:
    def myAtoi(self, s: str) -> int:
    min_ = -2147483648
    max_ = 2147483648
    s = s.lstrip()
    num_re = re.compile(r'^[\+\-]?\d+')
    num = num_re.findall(s)
    num = int(num)
    return max(min(num,max_), min_)

方法二：逻辑
完全按照题目来写条件。

class Solution:
    def myAtoi(self, s: str) -> int:
        neg = None 
        ans = ''
        #丢弃无用的前导空格
        new_s = s.lstrip()
        if not new_s: return 0 
        if new_s[0] =='-':
            neg = True
            new_s = new_s[1:]
        for i in new_s: 
            if neg is None and i =="+":neg = False 
            elif i.isdigit():
                ans += i 
            #读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。
            #字符串的其余部分将被忽略
            else: break  
        if not ans: return 0
        ans = int(ans)
        if neg: 
            ans = -ans 
            return max(ans,-2 ** 31)
        return min(ans,2 ** 31 - 1)

题目五：LT7. 整数反转

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−2^31, 2 ^ 31 − 1] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）

输入：x = 123
输出：321
输入：x = -123
输出：-321
输入：x = 120
输出：21

思路是如何反转数字呢？
用余数来做，举一个例子 12345
12345 % 10 --> 5 so ans = 5 , num = 1234
1234 % 10 = 4 so ans = 54, num = 123
123 % 10 = 3 so asn = 543 num = 12
12 % 10 = 2 so ans = 5432 num = 1
1% 10 =1 so ans = 54321 num = 0

但需要排除溢出的情况
假设有1147483649这个数字，它是小于最大的32位整数2147483647的，但是将这个数字反转过来后就变成了9463847411，这就比最大的32位整数还要大了

class Solution:
    def reverse(self, x: int) -> int:
        ans = 0
        neg = None 
        if x < 0: 
            neg = True 
            x = -x 
        while x!=0:
            left = x % 10
            #special cases 
            if ans > 214748364: return 0 
            if ans == 214748364 and left > 7: return 0      
            ans = ans * 10 + left 
            x = x//10 
        if neg: return -ans 
        else:return ans 

题目六：LT9. 回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是

输入：x = 121
输出：true
输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数
输入：x = -101
输出：false

跟上面差不多思路

class Solution:
    def isPalindrome(self, x: int) -> bool:
        #special cases 
        if x <0: return False 
        ans = 0 
        check = x 
        while x != 0:
            left = x% 10 
            if ans > 214748364: return False
            if ans == 214748364 and left > 7: return False 
            ans = ans * 10 + left 
            x = x//10
        return ans == check 

题目七：LT33. 搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值 互不相同 。
在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1

输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4
输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1
输入：nums = [1], target = 0
输出：-1

如果是有序数组的话，找一个数，直接用二分法就可以。但是现在是旋转过后的。是局部有序。
那么，可以用条件分开 看哪部分是有序的。

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        #special cases 
        if not nums:return -1 
        low = 0 
        end = len(nums)-1
        while low <= end:
            mid = (low+end)//2
            if nums[mid]==target: return mid
            #左边是有序的 
            if nums[0]<=nums[mid]:
                if nums[0]<= target < nums[mid]:
                    end = mid-1 
                else: 
                    low = mid + 1
            #右边是有序的
            else:
                if nums[mid]< target <= nums[len(nums)-1]:
                    low = mid + 1 
                else:
                    end = mid-1 
        return -1

时间复杂度是O(logn)

题目八：LT43. 字符串相乘

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式

输入: num1 = "2", num2 = "3"
输出: "6"
输入: num1 = "123", num2 = "456"
输出: "56088"

class Solution:
    def multiply(self, num1: str, num2: str) -> str:
        if num1 == '0' or num2 == '0':return '0'
        m,n = len(num1),len(num2)
        ans = [0]*(m+n)
        for i in range(m-1,-1,-1):
            for j in range(n-1,-1,-1):
                ans[i+j+1] += int(num1[i])*int(num2[j])
        
        for i in range(m+n-1,0,-1):
            ans[i-1] += ans[i]//10
            ans[i] = ans[i]%10

        if ans[0]==0:return ''.join(str(_) for _ in ans[1:])
        else:return ''.join(str(_) for _ in ans)
        

时间复杂度是O(mn)
空间复杂度是O(m+n)

题目九：LT43 dp编辑距离

给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。
你可以对一个单词进行如下三种操作：
插入一个字符
删除一个字符
替换一个字符

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        m,n = len(word1),len(word2)
        #special cases 
        if not m or not n: return max(m,n)

        #dp 
        dp = [[0]*(n+1) for _ in range(m+1)]
        for i in range(m+1):dp[i][0] = i 
        for j in range(n+1):dp[0][j] = j 
        for i in range(1,m+1):
            for j in range(1,n+1):
                if word1[i-1] == word2[j-1]:
                    p1 = dp[i-1][j-1]
                else: p1 = dp[i-1][j-1]+1
                dp[i][j]=min(p1, dp[i-1][j]+1,dp[i][j-1]+1)

        return dp[m][n]

时间复杂度和空间复杂度都是O(mn)

问题十：LT136. 只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗
意思是要求时间复杂度是O(N); 空间复杂度是O(1)

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

第一想法是哈希表，但是哈希表的话，空间复杂度必定不是1；所以不能使用哈希表
第二想法是用set 也是会使用空间
所以唯一的方法是用异或运算 来节约空间。

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        #位运算 
        #^的一些特性
        # a^a = 0 
        # a^0 = a 
        #所以可以利用这两个特性 一直相乘 最后得到的数就是只出现一次的数
        ans = nums[0]
        for i in range(1,len(nums)):
            ans = ans^nums[i]
        return ans