leecode题-Python3版

简单题

leetcode中国版官网：https://leetcode-cn.com
所有代码均在leecode中测试过，争取每周更新

1 两数之和

描述：给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
思路：
方法1 循环遍历两遍，超时
方法2 一边遍历一边找另一个满足条件的值

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        # 方法1
        # new_nums = []
        # for index_i,i in enumerate(nums):
        #     for index_j,j in enumerate(nums):
        #         if index_i!=index_j:
        #             if i+j==target:
        #                 new_nums.append(index_i)
        #                 new_nums.append(index_j)
        #                 return new_nums
        #             else:
        #                 continue
       
        #方法2
        for i in range(len(nums)):
            if (target-nums[i]) in nums[i+1:]:
                return [i,nums.index(target-nums[i],i+1)]

7 整数反转

描述：给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
思路：轮流遍历整数后从后往前join为新的整数，若为负数则取反

class Solution:
    def reverse(self, x: int) -> int:
        #判断输入是否溢出
        if x>=2**31-1 or x<=-1*2**31:
            return 0
        new2 = []
        flag = False #判断正负
        for index,i in enumerate(str(x)):
            if i !='-':
                new2.append(i)
            else:
                flag = True
        new_int=int(''.join(new2[::-1]))
        #若为负则取反
        if flag:
            new_int = -1*new_int
        #判断输出溢出
        if new_int>=2**31-1 or new_int<=-1*2**31:
            return 0
        else:
            return new_int

整合一下:

class Solution:
    def reverse(self, x: int) -> int:
        x = str(x)
        if x[0] == '-':
            new_x = -1*int(x[1:][::-1]) #从第二个字符起取反
        else:
            new_x = int(x[::-1]) #取反
        if new_x>=2**31-1 or new_x<=-1*2**31:
            return 0
        return new_x

9 回文数

描述：判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
思路：方法1:将int型转换为string，先将str按’,‘join再按’,'切分,最后从后往前join与原始字符串匹配
方法2:将int转为str后直接判断

#方法1:
class Solution:
    def isPalindrome(self, x: int) -> bool:
        return str(x)==''.join(','.join(str(x)).split(',')[::-1])

#方法2:
class Solution:
    def isPalindrome(self, x: int) -> bool:
        new_x = [x for index,x in enumerate(str(x))]
        return new_x[::]==new_x[::-1]

方法2整合一下：

class Solution:
    def isPalindrome(self, x: int) -> bool:
        return str(x)[::]==str(x)[::-1]

14 最长公共前缀

描述：编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 “”
思路：使用python自带的min函数和max函数,只需要比较最大最小的公共前缀就是整个数组的公共前缀

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        # 若输入为[]
        if len(strs)==0:
            return ""
        min_str = min(strs) #返回list中，第一个字母往后比较直至出现ASCII码 最小的字符串
        max_str = max(strs) ##返回list中，第一个字母往后比较直至出现ASCII码 最大的字符串
        # 找出相同的前缀
        for index,i in enumerate(min_str):
            if i!=max_str[index]:
                return min_str[:index]
        # 若输入list长度为1，包括[""]
        return min_str

20 有效的括号

描述：给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
    左括号必须用相同类型的右括号闭合。
    左括号必须以正确的顺序闭合。
思路：用栈保存读取的左括号，若下一个字符与栈顶元素对应的右括号不匹配或者此时栈为空则返回False，遍历一遍后若栈不为空则括号不匹配

class Solution:
    def isValid(self, s: str) -> bool:
        # 若括号数为奇数则说明括号不匹配
        if len(s)%2==1:
            return False
        dict_s = {'(':')','[':']','{':'}'}
        stack = [] #栈
        for i in s:
            if i in dict_s:
                stack.append(i)
            else:
                # 若栈为空 或者 当前字符不是与栈顶元素匹配的右括号，则说明括号不匹配
                if not stack or dict_s[stack.pop()]!=i:
                    return False
        return len(stack) ==0

26. 删除排序数组中的重复项

描述：给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
思路：依次比较数组中的前后两个元素，因为是有序数组，所以若是前后两个元素大小相等则删除其中一个

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        index = 0
        while index <len(nums)-1:
            if nums[index]==nums[index+1]:
                nums.pop(index)
            else:
                index +=1
        return len(nums)       

28 实现 strStr()

描述：给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
思路：
方法1:直接用python库查找
方法2：从index为0开始找haystack中长度为needle的串，与needle匹配

# 方法1
class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        if needle == '':
            return 0
        if needle in haystack:
            return haystack.index(needle)
        else:
            return -1

# 方法2
class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        if needle == '':
            return 0
        if len(haystack)<len(needle):
            return -1
        for i in range(len(haystack)):
            if haystack[i:][:len(needle)] == needle:
                return i
        return -1