最近在看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