【Leetcode】新手tag刷题笔记-算法简单题

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。

# 方法一
nums = [3,2,4];
print("输入的列表是：",nums);
targe = 6;
print("输入的targe是：",targe);
for i in range(0,3):
    for j in range(i+1,3):
        if (targe == nums[i] + nums[j]):
            print("[%s,%s]"%(i,j));

# 方法二哈希表
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashtable = dict()
        for i, num in enumerate(nums):
            if target - num in hashtable:
                return [hashtable[target - num], i]
            hashtable[nums[i]] = i
        return []

# 两数之和（twosum）
class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        map_a = dict()
        k = len(nums)
        for i in range(0, k):#一边将列表中的数添加到字典中，一边判断两数之差是否存在于字典中
            temp = target - nums[i]  
            if temp in map_a :  # 判断步骤
                return [map_a[temp], i]
            map_a[nums[i]] =  i  # 添加步骤（切记先判断再添加，以免key冲突）

20. 有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

# 方法一：使用栈，枚举
class Solution:
    def isValid(self, s: str) -> bool:
        n = len(s)
        if n == 0:
            return True
        stack = []
        for i in s:
            if i == '(' or i == '[' or i == '{':
                stack.append(i)
            else:
                if len(stack) == 0:
                    return False
                else:
                    temp = stack.pop()
                    if i == ')':
                        if temp != '(':
                            return False
                    elif i == '[':
                        if temp != ']':
                            return False
                    elif i == '}':
                        if temp != '{':
                            return False
        if len(stack) == 0:
            return True
        else:
            return False

not stack 指空栈

stack[-1] 指栈顶

# 方法二：使用栈，字典
class Solution:
    def isValid(self, s: str) -> bool:
        if len(s) % 2 == 1:# 如果是单数，则False
            return False
        # 建立一个字典，根据右括号来查找左括号
        pairs = {
   
            ")": "(",
            "]": "[",
            "}": "{",
        }
        stack = list()# 建立一个栈
        for ch in s:
            if ch in pairs:
                if not stack or stack[-1] != pairs[ch]:# 如果是空栈或者栈顶不等于左括号
                    return False
                stack.pop()
            else:
                stack.append(ch)
        
        return not stack

21. 合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

val（）函数语法为：

i. val（字符表达式）

val（）函数的功能为：将一组字符型数据的数字部分转换成相应的数值型数据
val（）函数用法：

# 这是个有序数列
class Solution:
    def mergeTwoLists(self, l1:list, l2:list)->list:
        if not l1:
            return l2
        if not l2:
            return l1
        if l1.val <= l2.val:# 取其中一个数
            l1.next = self.mergeTwoLists(l1.next,l2)
            return l1
        else:
            l2.next = self.mergeTwoLists(l1,l2.next)
            return l2

53. 最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

# 方法一暴力解法
nums = list(map(int,input().split()))
n = len(nums)
tmp = nums[0]
ans = tmp
for i in range(0, n):
    sum = 0
    for j in range(i, n):
        sum += nums[j]
        if sum > ans