100eahot

 1 pas

20 

class Solution:
    def isValid(self, s: str) -> bool:
        dic={')':'(',']':'[','}':'{'}
        res = []
        for i in s:
            if i in dic.keys():
                if not res or res[-1] != dic[i]:
                    return False
                res.pop()
            else:
                res.append(i)
        return res==[]

21

#merge sorted list
class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        newHead = ListNode(0)
        pre = newHead
        while l1 and l2:
            if l1.val<l2.val:
                pre.next = l1
                l1 = l1.next
            else:
                pre.next = l2
                l2 = l2.next
            pre = pre.next
        if l1:
            pre.next = l1
        elif l2:
            pre.next = l2
        return newHead.next

53

#max zi num sum
class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        l = len(nums) 
        i = 0 
        sum = 0 
        MaxSum = nums[0] 
        while i < l: 
            sum += nums[i] 
            if sum > MaxSum: 
                MaxSum = sum 
            if sum < 0: 
                sum = 0 
            i += 1 
        return MaxSum

70 pas

94

#tree mid order
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        def dfs(root):
            if not root:return 
            dfs(root.left)
            res.append(root.val)
            dfs(root.right)
        dfs(root)
        return res

101

#
class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:

        def same(node1,node2):
            if not node1 and not node2:return True
            if (node1 and not node2) or (not node1 and node2):
                return False
            return node1.val == node2.val and same(node1.right,node2.left) and same(node1.left,node2.right)
        if not root:return True
        return same(root.left,root.right)

104

#class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        return 1 + max(self.maxDepth(root.left),self.maxDepth(root.right))

121

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if len(prices)<2: return 0 
        min_price = prices[0] 
        max_profile = 0 
        for i in prices: 
            min_price = min(min_price, i) 
            max_profile = max(max_profile, i - min_price) 
        return max_profile

136

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        dic = {}
        for i in range(len(nums)):
            if nums[i] in dic:
                dic[nums[i]] += 1
            else:
                dic[nums[i]] =1
        for key,value in dic.items():
            if value ==1:
                return key
        

141

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        fast = slow = head 
        while fast and fast.next: 
            fast = fast.next.next 
            slow = slow.next 
            if slow == fast: 
                return True 
        return False

155

class MinStack:
    def __init__(self):
        self.stack = []
        self.min_stack = [math.inf]

    def push(self, x: int) -> None:
        self.stack.append(x)
        self.min_stack.append(min(x, self.min_stack[-1]))

    def pop(self) -> None:
        self.stack.pop()
        self.min_stack.pop()

    def top(self) -> int:
        return self.stack[-1]

    def getMin(self) -> int:
        return self.min_stack[-1]

160

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        A, B = headA, headB
        while A != B:
            A = A.next if A else headB
            B = B.next if B else headA
        return A

169

class Solution(object):
    def majorityElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) ==1:
            return nums[0]
        dict_ = {}
        for i in nums:
            if i in dict_:
                dict_[i] += 1
                if dict_[i] > len(nums)//2:
                    return i
            else:
                dict_[i] = 1
        return 0
        

206

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if head is None: return None
        p = head
        cur = None
        pre = None
        while p is not None:
            cur = p.next
            p.next = pre
            pre = p
            p = cur
        return pre 

226

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:return 
        root.left, root.right = self.invertTree(root.right),self.invertTree(root.left)
        return root

234

class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        h = ListNode(0)
        h = head
        l = []
        while h:
            l.append(h.val)
            h = h.next
        return True if l == l[::-1] else False

238

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        zero = 0
        for i in range(len(nums)):
            if nums[i] != 0 :
                nums[i],nums[zero] = nums[zero], nums[i]
                zero += 1

338

class Solution:
    def countBits(self, n: int) -> List[int]:
        def countOnes(x: int) -> int:
            ones = 0
            while x > 0:
                x &= (x - 1)
                ones += 1
            return ones
        
        bits = [countOnes(i) for i in range(n + 1)]
        return bits

448

class Solution:
    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
        #桶排序
        counter = set(nums)
        N = len(nums)
        res = []
        for i in range(1, N + 1):
            if i not in counter:
                res.append(i)
        return res

461

class Solution:
    def hammingDistance(self, x: int, y: int) -> int:
        x=bin(x).replace('0b','')
        y=bin(y).replace('0b','')
        m_length = max(len(x),len(y))
        newx= '0'*(m_length-len(x))+x
        newy= '0'*(m_length-len(y))+y
        count=0
        for i in range(m_length):
            if newx[i]!=newy[i]:
                count+=1
        return count

543

class Solution:
    def diameterOfBinaryTree(self, root: TreeNode) -> int:
        self.ans = 1
        def depth(node):
            # 
            if not node:
                return 0
            #
            L = depth(node.left)
            #
            R = depth(node.right)
            # 计算d_node即L+R+1 并更新ans
            self.ans = max(self.ans, L + R + 1)
            #
            return max(L, R) + 1
        depth(root)
        return self.ans - 1

617

class Solution:
    def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
        if not root1:return root2
        if not root2:return root1
        root1.val += root2.val
        root1.left = self.mergeTrees(root1.left,root2.left)
        root1.right = self.mergeTrees(root1.right,root2.right)
        return root1