leetcode-python 第十二周

最近在看course的题目，都是些简单的题目，每天花在上面的时间不多。

1.Delete Node In a Linked List [52ms]

# 方法1：双指针遍历，用后面的值代替前面的值
class Solution(object):
    def deleteNode(self, node):
        """
        :type node: ListNode
        :rtype: void Do not return anything, modify node in-place instead.
        """
        p = node
        q = node.next
        while q != None:
            p.val = q.val

            if q.next == None:
                p.next = None
                del q
                break
            p = p.next
            q = q.next

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

2. Insert Of Two Array II [39ms]

# 方法1：二指针
class Solution(object):
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        low1, high1 = 0, len(nums1)
        low2, high2 = 0, len(nums2)

        nums1.sort()
        nums2.sort()
        ans = []
        while low1 < high1 and low2 < high2:
            if nums1[low1] == nums2[low2]:
                ans.append(nums1[low1])
                low1 += 1
                low2 += 1
            elif nums1[low1] > nums2[low2]:
                low2 += 1
            else:
                low1 += 1
        return ans

3. Merge Two Sorted Lists [72ms]

class Solution(object):
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        if l1 == None: return l2
        if l2 == None: return l1

        if l1 != None and l2 != None:
            if l1.val > l2.val:
                tmp = ListNode(l2.val)
                tmp.next = l1
                l1 = tmp
                l2 = l2.next
        p1, p2 = l1, l1.next
        while p2 != None and l2 != None:
            if p2.val < l2.val:
                p1, p2 = p1.next, p2.next
            else:
                tmp = ListNode(l2.val)
                p1.next = tmp
                p1.next.next = p2
                p1 = p1.next
                l2 = l2.next
        if l2 != None:
            p1.next = l2
        return l1

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

4. Swqp Nodes in Pairs [39ms]

class Solution(object):
    def swapPairs(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head is None or head.next is None:
            return head

        p, q = head, head.next
        p.next = q.next
        q.next = p
        head = q
        p, q = q, p

        while q.next != None and q.next.next != None:
            p = q.next
            q.next = p.next
            p.next = p.next.next
            q.next.next = p
            p, q = q, p
        return head

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

5. Reversed Linked List [52ms]

# 方法1：开辟空间先储存在新建
class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head == None:
            return head

        val = []
        p = head
        while p != None:
            val.append(p.val)
            p = p.next

        rhead = ListNode(val[-1])
        q = rhead
        for i in range(-2, -len(val)-1, -1):
            tmp = ListNode(val[i])
            q.next = tmp
            q = q.next
        return rhead
# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

6. Maximum Depth of Binary Tree [146ms]

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root == None:
            return 0

        ans = self.goDown(root, 0)
        return ans

    def goDown(self, node, n):
        if node == None:
            return n
        else:
            return max(self.goDown(node.left, n+1), self.goDown(node.right, n+1))

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

7. Linked List Cycle [82ms]

# 方法1：快慢指针，刚开始以为它只会检测一定长度的环，
# 但是由于单向链表的结构，所以循环多几次就可以找到，毕竟快指针永远快一格
# 注意为空条件
class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        slow = head
        fast = head
        while slow != None and fast != None:
            slow = slow.next
            if fast.next != None:
                fast = fast.next.next
            else:
                return False

            if slow == fast:
                return True
        return False
# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None