2024.8.19 Python，简单题，all的用法，双指针，哈希表，找字符串，sorted，zip，map，二叉树的定义以及计算深度

1.在python里，可以并列if，可以不写else

2.接17号的找不同

字典强制转为列表，是保留键还是值，列表可以强制转为字典吗
是可以的，操作如下：
1.字典强制转换为列表，只保留键：

my_dict = {'a': 1, 'b': 2, 'c': 3}
my_list = list(my_dict)
print(my_list) #输出['a', 'b', 'c']

2.字典的值，强制转换为列表：

my_list = list(my_dict.values())
print(my_list) #输出[1, 2, 3]

3.也可以都：

my_list = list(my_dict.items())
print(my_list) #输出[('a', 1), ('b', 2), ('c', 3)]

4.列表转为字典：

my_list = ['a', 1, 'b', 2, 'c', 3]
my_dict = dict(zip(my_list[::2], my_list[1::2])) #从0到底，以2为隔断，从1到底，以2为隔断
print(my_dict) #输出{'a': 1, 'b': 2, 'c': 3}

3.zip的用法

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
zipped = zip(list1, list2)
print(list(zipped))  # [(1, 'a'), (2, 'b'), (3, 'c')]

zipped = [(1, 'a'), (2, 'b'), (3, 'c')]
list1, list2 = zip(*zipped)
print(list1)	#(1, 2, 3)
print(list2) 	#('a', 'b', 'c')

有点难理解，主要是形式感觉有点乱，之后有更多例子了再继续。

4.找不同

给定两个字符串 s 和 t ，它们只包含小写字母。
字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。
请找出在 t 中被添加的字母。
示例 1：
输入：s = “abcd”, t = “abcde”
输出：“e”
解释：‘e’ 是那个被添加的字母。

class Solution:
    def findTheDifference(self, s: str, t: str) -> str:
        s=sorted(s)+[' ']
        t=sorted(t)
        for c1,c2 in zip(s,t):
            if c1!=c2:       
                return c2

sorted会按顺序排列，然后给s补一个空格，用zip打包，对比

class Solution:
    def findTheDifference(self,s:str,t:str)->str:
        diff= Counter(t)-Counter(s)
        diff_list=list(diff)
        return diff_list[0]

5.找出字符串中第一个匹配项的下标

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。
示例 1：
输入：haystack = “sadbutsad”, needle = “sad”
输出：0
解释：“sad” 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。
示例 2：
输入：haystack = “leetcode”, needle = “leeto”
输出：-1
解释：“leeto” 没有在 “leetcode” 中出现，所以返回 -1 。
第一种：库函数：

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        return haystack.find(needle)

第二种：带有判断的库函数：

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
		return haystack.index(needle) if needle in haystack else -1
	#也就是说
	def strStr(self, haystack:str,needle:str)->int:
		if needle in haystack:
			return haystack.index(needle)
		else 
			return -1

都能这样写了，那python也太自由了吧

6.重复的子字符串

已解答
简单
相关标签
相关企业
给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。
示例 1:
输入: s = “abab”
输出: true
解释: 可由子串 “ab” 重复两次构成。
示例 2:
输入: s = “aba”
输出: false

class Solution:
	def repeatSubstringPattern(self,s:str)->bool:
		n=len(s)
		for i in range (1,n//2+1):
			if n%i==0:
				if all(s[j]==s[j-i]for j in range(i,n)):
					return True
		return False

这个题有好几种写法，第二种方法很巧但是学不到什么东西，第三种方法是KMP算法，不是现在的我能去理解的东西，没必要。
PS1这个all很好，再看，相当于and的嵌套，KMP算法可以之后有机会了看
PS2all是所有都正确才正确，any是只要有一个正确那就正确

7.移动零，双指针

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。
示例 1:
输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
示例 2:
输入: nums = [0]
输出: [0]

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        n = len(nums)
        left = right = 0
        while right < n:
            if nums[right] != 0:
                nums[left], nums[right] = nums[right], nums[left]
                left += 1
            right += 1

代码逻辑：
1.上来如果是0，left不动，right向右走，找第一个非0数
2.上来如果是非0，left和right相等，交换，然后继续向右走
3.右遇到0直接跳过，right+1，左等着，右遇到非0数，进入交换，并给left+1
4.右到顶，说明已经没有非0数了，停。

8.罗马数字

class Solution:
    def romanToInt(self, s: str) -> int:
        hashtable={'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
        res=0
        n=len(s)
        i=0
        while i<n:
            if i<n-1 and hashtable[s[i]]<hashtable[s[i+1]]:  #注意这里，先判断，不让超出
                res+=hashtable[s[i+1]]-hashtable[s[i]]
                i+=2
            else:
                res+=hashtable[s[i]]
                i+=1
        return res

这是一个非常好的哈希表的例子，而且用的也非常的好，没啥好说的。

9.交替存放（zip）

提示
给你两个字符串 word1 和 word2 。请你从 word1 开始，通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长，就将多出来的字母追加到合并后字符串的末尾。
返回 合并后的字符串
示例 1：
输入：word1 = “abc”, word2 = “pqr”
输出：“apbqcr”
解释：字符串合并情况如下所示：
word1： a b c
word2： p q r
合并后： a p b q c r
示例 2：
输入：word1 = “ab”, word2 = “pqrs”
输出：“apbqrs”
解释：注意，word2 比 word1 长，“rs” 需要追加到合并后字符串的末尾。
word1： a b
word2： p q r s
合并后： a p b q r s

class Solution:
    def mergeAlternately(self, word1: str, word2: str) -> str:
        ans = []
        for x, y in zip_longest(word1, word2, fillvalue=''):  #注意这里的fillvalue=''
            ans.append(x)
            ans.append(y)
        return ''.join(ans)

这个题的逻辑是这样的，假设：
word1 = “abc”
word2 = “pq”
执行 zip_longest(“abc”, “pq”, fillvalue=‘’) 后会得到以下元组序列：
(‘a’, ‘p’)
(‘b’, ‘q’)
(‘c’, ‘’)
然后他是分别append的，也就是说，ap出来的时候就已经分别append进去了，bq是下一次循环进去的，最后用join把字符列表改成字符串

10.map函数的用法

先说背景，这个题是想从[1,2,3]先转实数，然后再转实数列表输出成[1,2,4]，其中有几步非常的关键：
1.nums = ‘’.join(map(str, digits)) 给digits中的每个数先变成字符，然后再变串，后期通过强制转int就可以计算了
2.list(map(int, str(nums))) 给nums是实数，str(nums)变成数字字符串，map给每位都变成int，此时输出的话其实是124，然后list就变成了[1,2,4]
那我当时就想了，我直接list(124)行不行，实际是不行的，所以上面这种麻烦的步骤是必须要的。或者这样

nums = 124
ans = [int(digit) for digit in str(nums)]
print(ans)  # 输出: [1, 2, 4]

11.二叉树的深度计算

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
		left_depth=self.maxDepth(root.left)
		right_depth=self.maxDepth(root.right)
		return max(left_depth,right_depth)+1

代码逻辑：现在就假设只有两层，root=[1,2,3]那么带入第一次，self.maxDepth(root.left)带进去东西了，所以之后可以return 1，但是进去了以后，下一次迭代已经是空了，所以返回0，然后出来回到了第二层前面提到的return 1，然后再回到最开始的return 1+1
最小深度的代码如下：

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        
        # 计算左子树和右子树的最小深度
        left_depth = self.minDepth(root.left)
        right_depth = self.minDepth(root.right)
        
        # 如果其中一个子树为空，则返回不为空的子树的深度+1
        if not root.left or not root.right:
            return left_depth + right_depth + 1
        
        # 否则，返回左右子树中较小的深度，并加一
        return min(left_depth, right_depth) + 1

这个代码多了一个if not root.left or not root.right: return left_depth + right_depth + 1，就改成最小深度了