leetcode字符串刷题

344.反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        i, j = 0, len(s)-1
        while i < j:
            s[i], s[j] = s[j], s[i]
            j -=1
            i +=1
        return s

345.反转字符串中的元音字母
编写一个函数，以字符串作为输入，反转该字符串中的元音字母。

class Solution:
    def reverseVowels(self, s: str) -> str:
        char = set(['a','e','o','i','u','A','E','O','I','U'])
        left, right = 0, len(s)-1
        s = list(s)
        while left <right:
            if s[left] in char and s[right] in char:
                s[left], s[right] = s[right], s[left]
                left +=1
                right -=1
            if not s[left]  in char:
                left +=1
            if not s[right]  in char:
                right -=1

        return "".join(s)
#列表可以改变，字符串不可以改变，所以要先把字符串转化为列表，才能让头尾两个元音字母相互交换
#列表转化为字符串，"".join(s)，""里面的符号是连接字符的符号，如"-","+"等
#时间复杂度O(n),空间复杂度为O(1)

class Solution:
    def reverseVowels(self, s: str) -> str:
        char = set(['a','e','o','i','u','A','E','O','I','U'])
        left, right = 0, len(s)-1
        res = []
        for n in s:
            if n not in char:
                res.append(n)
            if n in char:
                while s[right] not in char:
                    right -=1
                res.append(s[right])
                right -=1

        return "".join(res) 

#时间复杂度O(n),空间复杂度为O(n) 

'''
438.找到字符串中所有字母的异位词
给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。

字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。

说明：

字母异位词指字母相同，但排列不同的字符串。
不考虑答案输出的顺序。
'''
class Solution:
    def findAnagrams(self, s: str, p: str) -> List[int]:
        string_p = {}
        string_w = {}
        left = 0
        right = 0
        result = []
        for i in p:
            string_p[i] = string_p.get(i, 0) +1
        while right < len(s):
            c = s[right]
            if c not in string_p:
                string_w.clear()
                left = right +1
                right = right +1
            else:
                string_w[c] = string_w.get(c,0) +1
                #dict.get(c,b)计算字典中key c对应的值的数目，没有就默认数量为b
                if right-left+1 == len(p):
                    if string_w == string_p:
                        result.append(left)
                    string_w[s[left]] -=1
                    left +=1
                    
                right +=1
        return result

3.无重复字符的最常字串
给定一个字符串，请你找出其中不含有重复字符的 最长子串的长度。
class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        substring = set()
        result = 0
        if len(s) <=1:
            return len(s)
        right = -1
        for i in range(len(s)):
            if i !=0:
                substring.remove(s[i-1])
            while right+1 <len(s) and s[right+1] not in substring:
                substring.add(s[right+1])
                right +=1
            result = max(result, right-i+1)
        return result
        

class Solution:
    def minWindow(self, s: str, t: str) -> str:
        need = collections.defaultdict(int)#字典need的值对应的格式是int
        for c in t:
            need[c] +=1
        neednum = len(t)
        i = 0
        result = (0, float('inf'))#元组
        for j, c in enumerate(s):
            if need[c] > 0:
                neednum -=1
            need[c] -=1

            if neednum == 0:
                while True:
                    if need[s[i]] ==0:
                        break # 跳出一层循环，若是continue则不执行该步，不跳出循环
                    else:
                        need[s[i]] +=1
                    i +=1
                if (result[1]-result[0]) > j-i:
                    result = (i,j)
                need[s[i]] +=1
                i +=1
                neednum +=1

        return '' if len(s) < result[1]-result[0] else s[result[0]: result[1]+1]

把一个有序的数组放到二叉树中
class BiTree:
    def __init__(self):
        self.data = None
        self.lchild = None
        self.rchild = None
def arraytotree(arr, start, end):
    root = None
    if end >= start:
        root = BiTree()
        root.data = arr[((start+end+1)//2)]
        root.lchild = arraytotree(arr, start,((start+end+1)//2 -1 ))
        root.rchild = arraytotree(arr, ((start+end+1)//2 +1), end)
    
    return root
用中序遍历打印出二叉树结点的值
def printTreeMidOrder(root):
    if root==None:
        return
    if root.lchild !=None:
        printTreeMidOrder(root.lchild)
    print(root.data)
    if root.rchild !=None:
        printTreeMidOrder(root.rchild)

if __name__ == "__main__":
    arr=[1,2,3,4,5,6,7,8]
    root = arraytotree(arr, 0 ,len(arr)-1)
    printTreeMidOrder(root)

76.最小覆盖字串