刷leetcode的一些经典算法的记录

283. Move Zeroes

        #这个算法nb了
        zero = 0  # records the position of "0"
        for i in range(len(nums)):
            if nums[i] != 0: #如果该位置不是0
                nums[i], nums[zero] = nums[zero], nums[i]
                zero += 1

 

219. Contains Duplicate II

        #给定一个数组，和一个整数k，判断该数组中是否存在不同下标的 i 和 j 两个元素，
        #使得 nums[i] = nums[j]，且 i 和 j 的差不超过k。
        dic = {} #建一个字典 key为值 value为index 
        for i, v in enumerate(nums): #枚举数据
            if v in dic and i - dic[v] <= k:#如果v在字典中并且 dic[v]表示的是index
                return True
            dic[v] = i
        return False

 

989. Add to Array-Form of Integer

        #完成int与str之间的互相转化 注意map与list函数的混合使用

        def list2int(l):
            s = list(map(str, l)) #将列表l中的每个元素变成str类型
            s = ''.join(s)
            return int(s)
        
        def int2list(i):
            s = str(i) 
            return list(map(int, s))
        
        return int2list(list2int(A) + K)
 

108. Convert Sorted Array to Binary Search Tree   经典，重在学习如何递归构造树

 class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        #已经排好序 那么选中间节点作为root 左侧为左树 右侧为右树
        #如果长度为0 则返回None
        if len(nums) == 0:
            return None
        return self.makeTree(nums,0,len(nums)-1)
    def makeTree(self,num,start,end):
        #如果start>end，则返回None
        if start > end:
            return None
        #如果start==end的话，则mid == start == end ，在下一个循环中 其left与right被设置为None
        mid = start + (end - start) // 2
        node = TreeNode(num[mid])
        node.left = self.makeTree(num,start,mid-1)
        node.right = self.makeTree(num,mid+1,end)
        return node 
        

107. Binary Tree Level Order Traversal II  #经典求树的每一层，并反向输出

        if not root:
            return []
        stack = []
        queue = [root]
        while queue:
            tempQueue = []
            level = []
            for node in queue:
                level.append(node.val)
                if node.left:
                    tempQueue.append(node.left)
                if node.right:
                    tempQueue.append(node.right)
            stack.append(level)
            queue = tempQueue
        return stack[::-1]

#226. Invert Binary Tree 

        if root is None:
            return
        
        root.left, root.right = root.right, root.left
        
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

206. Reverse Linked List

        #这个链表超级有意思  相当于加了一个小尾巴
        prev = None
        while head:
            curr = head
            head = head.next
            curr.next = prev
            prev = curr
        return prev

 

617. Merge Two Binary Trees

 

    def mergeTrees(self, t1, t2):
        """
        :type t1: TreeNode
        :type t2: TreeNode
        :rtype: TreeNode
        """
        #以一棵树为基准 ，另一棵树用来比较
        
        if not t1:
            return t2
        if not t2:
            return t1
        t = TreeNode(t1.val+t2.val)
        t.left = self.mergeTrees(t1.left, t2.left)
        t.right = self.mergeTrees(t1.right, t2.right)
        return t

897. Increasing Order Search Tree

    def increasingBST(self, root: TreeNode) -> TreeNode:
        
        res=[]
        def preorder(node):
            if node:
                preorder(node.left)
                res.append(node.val)
                preorder(node.right)
                
        preorder(root)
        print(res)
        tree=TreeNode(res[0])
        res=res[1:]
        new_root=tree
        for elem in res:
            tree.right=TreeNode(elem)
            tree=tree.right
        return new_root

949. Largest Time for Given Digits

    def largestTimeFromDigits(self, A: List[int]) -> str:
        #从四个数字里 分别找2与1与0的最大值，接下来的三个值中找4，3，2，1，0，再从两个数中找6，5，4，3，2，1，
        #再从一个数放在最后，如果倒数第二个数字为0，那么最后一个不为0的话，则返回‘’
        #当然最好这样遍历两个数，一个小于等于24，另一个等于60的最大值
        #first way
        k = sorted(list(itertools.permutations(A)),reverse=True)
        print(k)
        for i in k:            
            a,b,c,d = i
            su = (a*10+b)
            sd = (c*10+d) 

            if su < 24 and sd <60:
                return  f"{a}{b}:{c}{d}"  
        return ''
    
        #second way
        return max(["%d%d:%d%d" % t for t in itertools.permutations(A) if t[:2] < (2, 4) and t[2] < 6] or [""])

 

205. Isomorphic Strings

 

    def isIsomorphic(self, s: str, t: str) -> bool:
        #third way （失败）
        #return map(s.find, t) == map(t.find, s)  这个失败了
        
        #second way  zip  打包为元组的列表 "egg" 'add" 变成[(e,a),(g,g),(g,g)] set(s) 变成eg   set(t) 变成了ag
        return len(set(zip(s, t))) == len(set(s)) == len(set(t))
        #first way #这个方式要记住
        d1, d2 = {}, {}
        for i, val in enumerate(s):
            d1[val] = d1.get(val, []) + [i]    #d1 = {'e': [0], 'g': [1, 2]}
        for i, val in enumerate(t):
            d2[val] = d2.get(val, []) + [i]
        return sorted(d1.values()) == sorted(d2.values())

28. Implement strStr()

    def strStr(self, haystack: str, needle: str) -> int:
        #这尼玛  方法真的牛逼
        for i in range(len(haystack) - len(needle)+1):
            if haystack[i:i+len(needle)] == needle:
                return i
        return -1
        
        #这题有点动态规划的感觉，做试试  myway   has some problems
        array = [[0]*(len(haystack)+1)]*(len(needle)+1)

        for i in range(1,len(haystack)+1):
            for j in range(1,len(needle)+1):
                
                if haystack[i-1] == needle[j-1]:
                    print(i,j)
                    array[j][i] = array[j-1][i-1] + 1
                else:
                    array[j][i] = max(array[j][i-1],array[j-1][i])
        res = -999
        print(array)
        for i in array:
            res = max(res,max(i))
        if res == len(needle):return res
        else:return -1