题一：1.0151. 反转字符串中的单词

1.1 题目大意
描述：给定一个字符串 s。

要求：反转字符串中所有单词的顺序。

说明：

单词：由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的单词分隔开。
输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。
返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
。
s 包含英文大小写字母、数字和空格 ’ ’
s 中至少存在一个单词。

解题思路

这是一个偏向简单类型的算法题
解题点是对字符串以空格为分切点，得到一个列表，再以列表倒序进行拼接。

class Solution:
    def reverseWords(self, s: str) -> str:
        s=s.split()
        s=' '.join(s[::-1])
        return s;

提交结果：

题二：2.0043. 字符串相乘

2.1 题目大意
描述：给定两个以字符串形式表示的非负整数 num1 和 num2。

要求：返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

说明：

不能使用任何标准库的大数类型（比如 BigInteger）或直接将输入转换为整数来处理。
。
num1 和 num2 只能由数字组成。
num1 和 num2 都不包含任何前导零，除了数字0本身。

解题思路

题目说不能用python关键字把字符型封转成int，解题是需要把字符型转换成整形，这是题目的难点

通过字典构建”0“->0的映射，就能很好解决这个问题，能够参与运算

class Solution:
    def multiply(self, num1: str, num2: str) -> str:
        dic={"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}
        f1=1
        ans=0
        for i in range(len(num1)-1,-1,-1):
            f2=1
            n1=dic[num1[i]]*f1
            for j  in range(len(num2)-1,-1,-1):
                n2=dic[num2[j]]*f2
                ans+=n1*n2
                f2*=10
            f1*=10
        return str(ans)

题三：3.0014. 最长公共前缀

3.1 题目大意
描述：给定一个字符串数组 strs。

要求：返回字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 “”。
说明：

strs[i] 仅由小写英文字母组成。

解题思路

找出里面长度最短的字符串，然后循环比对，依次减一。

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        item=""
        for num in strs:
            if len(item)==0 or len(num)<len(item):
                item=num
        for num in strs:
            while num.find(item)!=0:
                item=item[:-1]
        return item

144. 二叉树的前序遍历

# 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 preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        stack,value=[root],[]
        while stack:
            node=stack.pop()
            value.append(node.val)
            if node:
                if node.right:
                    stack.append(node.right)
                if node.left:
                    stack.append(node.left)
        return value

144. 二叉树的中序遍历

# 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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        tree=[]
        def helper(root):
            if not root:
                 return []
            helper(root.left)  # 中序遍历左子树
            tree.append(root.val)
            helper(root.right)  # 中序遍历右子树
            return tree
        tree=helper(root)
        return tree

3.0102. 二叉树的层序遍历

# 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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        queue=[root]
        tree=[]
        i=0
        while queue:
            size=len(queue)
            tree1=[]
            for _ in range(size):
                node=queue.pop(0)
                tree1.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            tree.append(tree1)
            i += 1
        return tree