LeetCode 简单难度题

持续更新…
二叉树的题后续再更新

1、两数相加

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
示例：
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

暴力求解法：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        length = len(nums)
        ret = []
        for i in range(length-1):
            for j in range(i + 1,length):
                if nums[i] + nums[j] == target:
                    ret.append(i)
                    ret.append(j)
        return ret

稍微的优化一下：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        length = len(nums)
        ret = []
        for i in range(length-1):
            tmp = target - nums[i]
            if tmp in nums[i+1:]:
                ret.append(i)
                ret.append(i+1 + nums[i+1:].index(tmp))
            
        return ret

7、整数翻转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-integer
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def reverse(self, x: int) -> int:
        nums = []
        flag = 1
        if x < 0:
            flag = -1
            x = abs(x)
        while x != 0:
            nums.append((x % 10))
            x = x // 10
        ret = 0
        for i in range(len(nums)):
            ret = ret * 10 + nums[i]
        if ret*flag >= -(2**31) and ret * flag <= 2**31-1:
            return ret*flag
        else:
            return 0

9、回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分离出每一位的数字，然后进行比对

class Solution:
    def isPalindrome(self, x: int) -> bool:
        if x < 0:
            return False
        if x == 0:
            return True
        nums = []
        while x != 0:
            nums.append(x % 10)
            x = x // 10
        if nums[::-1] == nums:
            return True
        else:
            return False

将数字转换为字符串进行比对

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

13、罗马数字转整数

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
字符 - 数值
I - 1
V - 5
X - 10
L - 50
C - 100
D - 500
M - 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。
示例 1:
输入: “III”
输出: 3
示例 2:
输入: “IV”
输出: 4
示例 3:
输入: “IX”
输出: 9
示例 4:
输入: “LVIII”
输出: 58
解释: L = 50, V= 5, III = 3.
示例 5:
输入: “MCMXCIV”
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/roman-to-integer
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def romanToInt(self, s: str) -> int:
        i = 0
        count = 0
        length = len(s)
        while i < length:
            if s[i] == 'V':
                count += 5
                i += 1
            elif s[i] == 'L':
                count += 50
                i += 1
            elif s[i] == 'D':
                count += 500
                i += 1
            elif s[i] == 'M':
                count += 1000
                i += 1
            elif s[i] == 'I':
                if i == length-1:
                    count += 1
                    i += 1
                else:
                    if s[i + 1] == 'V':
                        count += 4
                        i += 2
                    elif s[i + 1] == 'X':
                        count += 9
                        i += 2
                    else:
                        count += 1
                        i += 1
            elif s[i] == 'X':
                if i == length - 1:
                    count += 10
                    i += 1
                else:
                    if s[i + 1] == 'L':
                        count += 40
                        i += 2
                    elif s[i + 1] == 'C':
                        count += 90
                        i += 2
                    else:
                        count += 10
                        i += 1
            elif s[i] == 'C':
                if i == length - 1:
                    count += 100
                    i += 1
                else:
                    if s[i + 1] == 'D':
                        count += 400
                        i += 2
                    elif s[i + 1] == 'M':
                        count += 900
                        i += 2
                    else:
                        count += 100
                        i += 1
        return count
            

14、最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。
示例 1:
输入: [“flower”,“flow”,“flight”]
输出: “fl”
示例 2:
输入: [“dog”,“racecar”,“car”]
输出: “”
解释: 输入不存在公共前缀。
说明:
所有输入只包含小写字母 a-z 。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-common-prefix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        length = []
        if not strs:
            return ''
        for i in range(len(strs)):
            length.append(len(strs[i]))
        mini_len = min(length)
        re = ''
        len_str = len(strs)
        for j in range(mini_len):
            tmp = strs[0][j]
            for i in range(len_str):
                if strs[i][j] != tmp:
                    return re
            re += tmp
        return re

20、有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1:
输入: “()”
输出: true
示例 2:
输入: “()[]{}”
输出: true
示例 3:
输入: “(]”
输出: false
示例 4:
输入: “([)]”
输出: false
示例 5:
输入: “{[]}”
输出: true
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/valid-parentheses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        for i in range(len(s)):
            if s[i] == '(' or s[i] =='[' or s[i] == '{':
                stack.append(s[i])
            else:
                if not stack:
                    return False
                top = stack.pop()
                if not((top == '(' and s[i] == ')') or (top == '[' and s[i] == ']') or (top == '{' and s[i] == '}') ):
                    return False
        if len(stack) != 0:
            return False
        return True

21、合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-two-sorted-lists
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        result = ListNode(0)
        re = result
        value = []
        while l1:
            value.append(l1.val)
            l1 = l1.next
        while l2:
            value.append(l2.val)
            l2 = l2.next
        value = sorted(value)
        for i in range(len(value)):
            result.next = ListNode(value[i])
            result = result.next
        return re.next

53、最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
示例:
输入: [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-subarray
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        if not nums:
            return
        if len(nums) == 1:
            return nums[0]
        max_sum = nums[0]
        current_sum = nums[0]
        for i in range(1,len(nums)):
            current_sum = max(current_sum+nums[i],nums[i])
            max_sum = max(max_sum,current_sum)
        return max_sum

58、最后一个单词的长度

给定一个仅包含大小写字母和空格 ’ ’ 的字符串 s，返回其最后一个单词的长度。如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。
如果不存在最后一个单词，请返回 0 。
说明：一个单词是指仅由字母组成、不包含任何空格字符的 最大子字符串。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/length-of-last-word
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def lengthOfLastWord(self, s: str) -> int:
        if not s:
            return 0
        for i in s.split(' ')[::-1]:
            if len(i) != 0:
                return len(i)
        return 0

66、加一

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1：
输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。
示例 2：
输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。
示例 3：
输入：digits = [0]
输出：[1]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/plus-one
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

将其转换为数字 进行计算

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        digit = 0
        for i in range(len(digits)):
            digit = digit * 10 + digits[i]
        digit += 1
        re = []
        while digit:
            re.append(digit%10)
            digit = digit // 10
        if len(re) < len(digits):
            while len(re) != len(digits):
                re.append(0)
        return re[::-1]

直接计算

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        if digits[-1] < 9:
            digits[-1] += 1
            return digits
        digits = digits[::-1]
        flag = True
        i = 0
        while flag and i < len(digits) - 1:
            digits[i] = 0
            i += 1
            if digits[i] < 9:
                flag = False
            else:
                flag =  True
        if flag == False and i == len(digits) - 1:
            digits[-1] += 1    
        if flag == False and i != len(digits) - 1:
            digits[i] += 1
        if flag == True:
            digits[-1] = 0
            digits.append(1)
        return digits[::-1]

67、二进制求和

给你两个二进制字符串，返回它们的和（用二进制表示）。
输入为 非空 字符串且只包含数字 1 和 0。
示例 1:
输入: a = “11”, b = “1”
输出: “100”
示例 2:
输入: a = “1010”, b = “1011”
输出: “10101”
提示：
每个字符串仅由字符 ‘0’ 或 ‘1’ 组成。
1 <= a.length, b.length <= 10^4
字符串如果不是 “0” ，就都不含前导零
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-binary
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

转换成十进制进行计算

class Solution:
    def addBinary(self, a: str, b: str) -> str:
        int_a = 0
        int_b = 0
        for i in range(len(a)):
            int_a = int_a * 2 + int(a[i])
        for i in range(len(b)):
            int_b = int_b * 2 + int(b[i])
        s = int_a + int_b
        return bin(s).split('b')[1]

class Solution:
    def addBinary(self, a: str, b: str) -> str:
        int_a = int(a,2)
        int_b = int(b,2)
        s = int_a + int_b
        return bin(s).split('b')[-1]

69、x的平方根

实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
示例 1:
输入: 4
输出: 2
示例 2:
输入: 8
输出: 2
说明: 8 的平方根是 2.82842…,
由于返回类型是整数，小数部分将被舍去。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sqrtx
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

暴力试

class Solution:
    def mySqrt(self, x: int) -> int:
        n = 1
        while n*n <= x:
            n += 1
        return n-1

采用二分法

class Solution:
    def mySqrt(self, x: int) -> int:
        if x < 0:
            return 
        if x == 0:
            return 0
        if x == 1:
            return 1
        tmp = x
        half = tmp // 2
        while True:
            
            if half * half > tmp:
                half = half // 2
            elif half * half == tmp:
                return half
            else:
                if (half+1)*(half+1) > tmp:
                    return half
                else:
                    half += 1

70、爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
示例 1：
输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1 阶 + 1 阶
2 阶
示例 2：
输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1 阶 + 1 阶 + 1 阶
1 阶 + 2 阶
2 阶 + 1 阶
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/climbing-stairs
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

就是斐波那契数列

class Solution:
    def climbStairs(self, n: int) -> int:
        if n == 0:
            return 0
        if n == 1:
            return 1
        fib = [1,1]
        for i in range(2,n+1):
            fib.append(fib[i-1] + fib[i-2])
        return fib[-1]

83、删除排序链表中的重复元素

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
示例 1:
输入: 1->1->2
输出: 1->2
示例 2:
输入: 1->1->2->3->3
输出: 1->2->3
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        result = ListNode('a')
        re = result
        while head:
            if head.val != result.val:
                p = ListNode(head.val)
                result.next = p
                result = result.next
                head = head.next
            else:
                head = head.next
        return re.next

88、合并两个数组

给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
说明：
初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。
示例：
输入：
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

采用 双指针，从后往前比对

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        if m == 0:
            nums1[:n] = nums2[:n]
        else:
            i = m - 1
            j = n - 1
            k = m + n - 1
            while i >= 0 and j >= 0:
                if nums1[i] <= nums2[j]:
                    nums1[k] = nums2[j]
                    k -= 1
                    j -= 1
                else:
                    nums1[k] = nums1[i]
                    k -= 1
                    i -= 1
            if j >= 0:
                 nums1[:k+1] = nums2[:j+1]

100、相同的树

给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
示例 1:
输入:
1 1
/ \ / \
2 3 2 3
[1,2,3], [1,2,3]
输出: true
示例 2:
输入:
1 1
/ \
2 2
[1,2], [1,null,2]
输出: false
示例 3:
输入:
1 1
/ \ / \
2 1 1 2
[1,2,1], [1,1,2]
输出: false
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/same-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

采用递归判断

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if not p and not q: # 为叶子节点
            return True
        if not p: #一方为叶子节点
            if q:
                return False
        elif not q: #一方为叶子节点
            if p:
                return False
        elif p.val == q.val:
            rt = self.isSameTree(p.right,q.right)
            lt = self.isSameTree(p.left,q.left)
            return rt and lt
        else:
            return False

101、对称二叉树

给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/ \
2 2
/ \ / \
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1
/ \
2 2
\ \
3 3
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/symmetric-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

采用镜像的思维，定义一个新函数

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        else:
            return self.isSym(root.left,root.right)

    def isSym(self,root1:TreeNode,root2:TreeNode) -> bool:
        if not root1 and not root2:
            return True
        elif not root1:
            return False
        elif not root2:
            return False
        if root1.val != root2.val:
            return False
        else:
            return self.isSym(root1.right,root2.left) and self.isSym(root1.left,root2.right)

104、二叉树的最大深度

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/ \
9 20
/ \
15 7
返回它的最大深度 3 。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

比对根节点的左右子树的高度，并返回较大高度值+1

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        else:
            right = self.maxDepth(root.right)
            left = self.maxDepth(root.left)
            return max(right,left) + 1

118、杨辉三角

给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。
在杨辉三角中，每个数是它左上方和右上方的数的和。
示例:
输入: 5
输出:
[
[1],
[1,1],
[1,2,1],
[1,3,3,1],
[1,4,6,4,1]
]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/pascals-triangle
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        if numRows == 0:
            return []
        if numRows == 1:
            return [[1]]
        if numRows == 2:
            return [[1],[1,1]]
        re = [[1],[1,1]]
        for i in range(2,numRows):
            tmp = [1]
            for j in range(0,len(re[-1])-1):
                tmp.append(re[-1][j] + re[-1][j+1])
            tmp.append(1)
            re.append(tmp)
        return re

119、杨辉三角②

给定一个非负索引 k，其中 k ≤ 33，返回杨辉三角的第 k 行。
在杨辉三角中，每个数是它左上方和右上方的数的和。
示例:
输入: 3
输出: [1,3,3,1]
进阶：
你可以优化你的算法到 O(k) 空间复杂度吗？
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/pascals-triangle-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

第一种方法：利用118题的代码，直接返回rowIndex行的结果就行

class Solution:
    def getRow(self, rowIndex: int) -> List[int]:
        if rowIndex == 0:
            return [1]
        if rowIndex == 1:
            return [1,1]
        re = [[1],[1,1]]
        for i in range(1,rowIndex):
            tmp = [1]
            for j in range(0,len(re[-1])-1):
                tmp.append(re[-1][j] + re[-1][j+1])
            tmp.append(1)
            re.append(tmp)
        return re[-1]

第二种方法：每次更新最新的杨辉三角最后一排的值

class Solution:
    def getRow(self, rowIndex: int) -> List[int]:
        if rowIndex == 0:
            return [1]
        if rowIndex == 1:
            return [1,1]
        re = [1,1]
        for i in range(1,rowIndex):
            tmp = [1]
            for j in range(0,len(re)-1):
                tmp.append(re[j] + re[j+1])
            tmp.append(1)
            re = tmp
        return re
            

121、买卖股票的最佳时机

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。
注意：你不能在买入股票前卖出股票。
示例 1:
输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 2:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

第一种 暴力法求解

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        maxi = 0
        for i in range(len(prices)-1):
            m = max(prices[i:])
            if (m - prices[i]) > maxi:
                maxi = m - prices[i]
        return maxi 

第二种 类似于动态规划

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if not prices:
            return 0
        min_price = prices[0]
        max_profit = 0
        for price in prices:
            min_price = min(price,min_price)
            max_profit = max(max_profit,price-min_price)
        return max_profit

123、买卖股票问题②

125、验证回文串

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
说明：本题中，我们将空字符串定义为有效的回文串。
示例 1:
输入: “A man, a plan, a canal: Panama”
输出: true
示例 2:
输入: “race a car”
输出: false
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/valid-palindrome
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

暴力求解法，把所有字母和数字用数组记录下来，而后将数组进行反转，比对是否正确

class Solution:
    def isPalindrome(self, s: str) -> bool:
        rr = []
        for word in s:
            if (word >='a' and word <= 'z') or (word >= 'A' and word <= 'Z'):
                rr.append(word.lower())
            if(word >= '0' and word <= '9'):
                rr.append(word)
        rr_tmp = rr
        rr_inverse = rr[::-1]
        if rr_tmp == rr_inverse:
            return True
        else:
            return False

136、只出现一次的数字

第一种方法：求每个元素的个数，返回只出现一次的数字

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        for i in nums:
            if nums.count(i) == 1:
                return i

但这种方法耗时长

第二种：利用和的差值

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        return sum(set(nums)) * 2 - sum(nums)

155、最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。
示例:
输入：
[“MinStack”,“push”,“push”,“push”,“getMin”,“pop”,“top”,“getMin”]
[[],[-2],[0],[-3],[],[],[],[]]
输出：
[null,null,null,null,-3,null,0,-2]
解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/min-stack
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

采用数组

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack = []

    def push(self, x: int) -> None:
        self.stack.append(x)

    def pop(self) -> None:
        self.stack.pop(-1)

    def top(self) -> int:
        return self.stack[-1]

    def getMin(self) -> int:
        return min(self.stack)


# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(x)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

167、两数之和II—输入有序数组

给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。
函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。
说明:
返回的下标值（index1 和 index2）不是从零开始的。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。
示例:
输入: numbers = [2, 7, 11, 15], target = 9
输出: [1,2]
解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

暴力求解法

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:

        for i in range(len(numbers) - 1):
            for j in range(i+1,len(numbers)):
                if numbers[i] + numbers[j] == target:
                    return [i+1,j+1]
                if numbers[i] + numbers[j] > target:
                    break
        return []

但会超出时间限制

方法二：采用双指针

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        start = 0
        end = len(numbers) - 1
        while start < end:
            # tmp = numbers[start] + numbers[end]
            if numbers[start] + numbers[end] == target:
                return [start + 1,end + 1]
            elif numbers[start] + numbers[end] > target:
                end -= 1
            else:
                start += 1
        return []