2023-06-04

Author: JiayangWu

0002.两数相加/0002-两数相加 2.py

@@ -0,0 +1,39 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def addTwoNumbers(self, l1, l2):
+        """
+        :type l1: ListNode
+        :type l2: ListNode
+        :rtype: ListNode
+        """
+        if self.getLength(l1) < self.getLength(l2):
+            l1, l2 = l2, l1
+        head = l1
+        while(l2):
+            l1.val += l2.val
+            l1 = l1.next
+            l2 = l2.next
+        
+        p = head
+        while(p):
+            if p.val > 9:
+                p.val -= 10
+                if p.next:
+                    p.next.val += 1
+                else:
+                    p.next = ListNode(1)
+            p = p.next   
+        return head
+        
+        
+    def getLength(self, l):
+        tmp = 0
+        while(l):
+            tmp += 1
+            l = l.next
+        return tmp

0009.回文数/0009-回文数 2.py

@@ -0,0 +1,17 @@
+class Solution(object):
+    def isPalindrome(self, x):
+        """
+        :type x: int
+        :rtype: bool
+        """
+        #2019.6.1
+        xx = x
+        if x < 0:
+            return False
+
+        reverse = 0
+        while x > 0:
+            x, tmp = divmod(x, 10)
+            reverse = reverse * 10 + tmp
+
+        return reverse == xx

0019.删除链表的倒数第N个结点/0019-删除链表的倒数第N个结点.py

@@ -0,0 +1,28 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
+        l = 0
+        p = head
+        while p:
+            l += 1
+            p = p.next
+
+        count = l - n + 1
+
+        dummy = ListNode(-1)
+        dummy.next = head
+        cur = -1
+        p = dummy
+        while p:
+            cur += 1
+            if cur == count - 1:
+                node_to_be_deleted = p.next
+                p.next = node_to_be_deleted.next
+                break
+            p = p.next
+        
+        return dummy.next

0020.有效的括号/0020-有效的括号 2.py

@@ -0,0 +1,16 @@
+class Solution(object):
+    def isValid(self, s):
+        """
+        :type s: str
+        :rtype: bool
+        """
+        dic = {")": "(", "]":"[", "}":"{"}
+        stack = []
+        for ch in s:
+            if ch in ["(", "[", "{"]:
+                stack.append(ch)
+            else:
+                if not stack or dic[ch] != stack[-1]:
+                    return False
+                stack.pop()
+        return len(stack) == 0 

0021.合并两个有序链表/0021-合并两个有序链表 2.py

@@ -0,0 +1,33 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def mergeTwoLists(self, l1, l2):
+        """
+        :type l1: ListNode
+        :type l2: ListNode
+        :rtype: ListNode
+        """
+        dummy = ListNode(-1)
+        
+        p = dummy
+        
+        while l1 and l2:
+            if l1.val <= l2.val:
+                p.next = ListNode(l1.val)
+                l1 = l1.next
+            else:
+                p.next = ListNode(l2.val)
+                l2 = l2.next
+            p = p.next
+            
+        if l1:
+            p.next = l1
+            
+        if l2:
+            p.next = l2
+            
+        return dummy.next

0022.括号生成/0022-括号生成 2.py

@@ -0,0 +1,22 @@
+class Solution(object):
+    def generateParenthesis(self, n):
+        """
+        :type n: int
+        :rtype: List[str]
+        """
+        
+        res = []
+        
+        def dfs(tmp, left, right):
+            if len(tmp) == 2 * n:
+                res.append(tmp)
+                
+            if left:
+                dfs(tmp + "(", left - 1, right)
+            if right > left:
+                dfs(tmp + ")", left, right - 1)
+                    
+            
+        dfs("", n, n)
+        return res
+        

0024.两两交换链表中的节点/0024-两两交换链表中的节点 2.py

@@ -0,0 +1,26 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def swapPairs(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+        if not head or not head.next:
+            return head
+        dummy = ListNode(1)
+        dummy.next = head
+
+        first = head
+        second = head.next
+        
+        tail = second.next
+        first.next = self.swapPairs(tail)
+        second.next = first
+        dummy.next = second
+        
+        return dummy.next

0026.删除有序数组中的重复项/0026-删除有序数组中的重复项.py

@@ -0,0 +1,10 @@
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+        visited = set()
+        index = 0
+        for num in nums:
+            if num not in visited:
+                visited.add(num)
+                nums[index] = num
+                index += 1
+        return index

0027.移除元素/0027-移除元素 2.py

@@ -0,0 +1,21 @@
+class Solution(object):
+    def removeElement(self, nums, val):
+        """
+        :type nums: List[int]
+        :type val: int
+        :rtype: int
+        """
+        nums.sort()
+        for i, num in enumerate(nums):
+            if num == val:
+                j = i + 1
+                while(j < len(nums) and nums[j] == num):
+                    j += 1
+                t = j
+                while(j < len(nums)):
+                    nums[i] = nums[j]
+                    i += 1
+                    j += 1
+                return i
+                
+                    

0028.找出字符串中第一个匹配项的下标/0028-找出字符串中第一个匹配项的下标.py

@@ -0,0 +1,5 @@
+class Solution:
+    def strStr(self, haystack: str, needle: str) -> int:
+        if needle not in haystack:
+            return -1
+        return haystack.index(needle)