def merge(linked_lists):
merged = []
# We can collect all nodes in O(n) time, where n is the number of elements
for node in linked_lists:
while node:
merged.append(node.val)
node = node.next
# Sorts in O(n log n) time, which results in O(n + n log n), or just O(n log n) time complexity
sorted_list = sorted(merged)
# if the return type should be array
# just return sorted_list
# if the return type should be Node
# we need to collect all elements again but this time into a linked list of type Node
# this step adds O(n) time, but the resulting complexity still remains O (n log n)
sorted_linked_list = ListNode()
# so we still can have access to the first node
head = sorted_linked_list
for value in sorted_list:
# Node (value) points to tail, which is None
sorted_linked_list.next = ListNode(value)
sorted_linked_list = sorted_linked_list.next
# return the first node
return head.next
def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
if not head:
return head
dummy = ListNode(-1) # 哑节点
dummy.next = head
if m > n:
m, n = n, m
if n > m:
p = dummy
prePm = None
for _ in range(m):
prePm = p
p = p.next
pM = p
pNext = p.next
for _ in range(n - m):
pPre = p
p = pNext
pNext = p.next
p.next = pPre
pM.next = pNext
prePm.next = p
return dummy.next
def run_test_case(t: testlib.unittest.TestCase, tc: Tuple[List[int], int, List[int]]):
head = ListNode.fromList(tc[0])
el_to_remove = head
for _ in range(tc[1]):
el_to_remove = el_to_remove.next
Solution().deleteNode(el_to_remove)
t.assertEqual(repr(head), repr(ListNode.fromList(tc[2])))
def push(self, value):
newnode = ListNode(value, self._top)
if self._top is None:
self._top = newnode
else:
newnode._next = self._top
self._top = newnode
def reverseBetween(self, head, m, n):
"""
:type head: ListNode
:type m: int
:type n: int
:rtype: ListNode
"""
if not head:
return head
dummy = ListNode(-1)
dummy.next = head
left, cur = dummy, head
k = n - m + 1
while m > 1:
left = cur
cur = cur.next
m -= 1
# reserve k times
start = cur
prev = None
while k:
tmp = cur.next
cur.next = prev
prev = cur
cur = tmp
k -= 1
# connect together
left.next = prev
start.next = cur
return dummy.next
def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
if not head or k == 1:
return head
dummy = ListNode(-1)
dummy.next = head
l, r = dummy, dummy
step = 0
while r:
r = r.next
if r:
step += 1
if step == k:
step = 0
# 翻转 l 和r 之间的所有节点
tmp = l.next
prev = r.next
while True:
next = tmp.next
tmp.next = prev
prev = tmp
if tmp == r:
break
tmp = next
tmp = l.next
l.next = r
l, r = tmp, tmp
return dummy.next
def test_delete_duplicates_2(self):
node5 = ListNode(3, None)
node4 = ListNode(3, node5)
node3 = ListNode(2, node4)
node2 = ListNode(1, node3)
node1 = ListNode(1, node2)
test = self.leet83.delete_duplicates(node1)
self.assertEqual(test.next.next.val, 3)
def array_to_listnode(array):
if len(array) > 0:
head = ListNode(array[0])
temp = head
for e in array[1:]:
node = ListNode(e)
temp.next = node
temp = temp.next
return head
def test_has_value(self):
node1 = ListNode(15)
node2 = ListNode(8.2)
node3 = ListNode("Berlin")
self.assertTrue(node1.has_value(15))
self.assertTrue(node2.has_value(8.2))
self.assertTrue(node3.has_value("Berlin"))
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
nodes = []
for list in lists:
while list:
nodes.append(list.val)
list = list.next
head = point = ListNode(-1)
for x in sorted(nodes):
point.next = ListNode(x)
point = point.next
return head
def _addToTail(self, node: ListNode):
"""Add node to tail."""
if not self.head:
self.head = node
return
parent = self.head
while parent.nextNode:
parent = parent.nextNode
node.setNextNode(parent.getNextNode())
parent.setNextNode(node)
def string_to_list_node(string):
# Generate list from the input
numbers = string_to_integer_list(string)
# Now convert that list into linked list
dummy_root = ListNode(0)
ptr = dummy_root
for number in numbers:
ptr.next = ListNode(number)
ptr = ptr.next
ptr = dummy_root.next
return ptr
def addNode(self, data: int, addToTail: bool = False):
"""Add new node to the SinglyLinked List.
:param int data: data to be stored in linked list
:param bool addToTail: Indicate whether data to be added at tail
"""
if self.findNode(data):
raise Exception("Duplicate Data")
node = ListNode(data)
if addToTail:
return self._addToTail(node)
node.setNextNode(self.head)
self.head = node
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
result = []
head = current = ListNode(0)
for l in lists:
while l:
result.append(l.val)
l = l.next
for v in sorted(result):
current.next = ListNode(v)
current = current.next
return head.next
def add_list_item(self, item):
if (not isinstance(item, ListNode)):
item = ListNode(item)
if (self.head is None):
self.head = item
item.next = None
item.prev = None
self.tail = item
else:
self.tail.next = item
item.prev = self.tail
self.tail = item
def main():
# print("Starting")
# head1 = ListNode(1)
# head1.next = ListNode(3)
# head1.next.next = ListNode(16)
# # head1.next.next.next = ListNode(5)
# tmp = head1
# head2 = ListNode(1)
# head2.next = ListNode(1)
# head2.next.next=ListNode(9)
sol=Solution()
# head3 = sol.mergeSortedLists(head1,head2)
# tmp = head3
sample_del=ListNode(1)
sample_del.next=ListNode(1)
sample_del.next.next=ListNode(2)
sample_del.next.next.next=ListNode(3)
sample_del.next.next.next.next=ListNode(3)
sample_del.next.next.next.next.next=ListNode(4)
head4=sol.deleteDuplicates(sample_del)
tmp_del=head4
while tmp_del:
print(tmp_del.val)
tmp_del=tmp_del.next
print ("\n\n")
def deleteDuplicates(self, list_node):
if not list_node:
return list_node
head = ListNode(None)
head.next = list_node
previous_node = head
current_node = head.next
while current_node:
next_node = current_node.next
if previous_node.val == current_node.val:
self.unlink_list_node(previous_node, current_node)
else:
previous_node = current_node
current_node = next_node
return head.next
def get_detect_cycle_result(self, list_node_string, position):
linked_list = string_to_list_node(list_node_string)
linked_list = self.make_linked_list_cycle(linked_list, position)
list_node = self.solution.detectCycle(linked_list)
if list_node:
list_node = ListNode(list_node.val)
return list_node_to_string(list_node)
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
if not lists:
return None
# 删掉空节点
lists = [a for a in lists if a]
if not lists:
return None
head = ListNode(-1)
tail = head
priority_queue = PriorityQueue()
for index, node in enumerate(lists):
priority_queue.put((node.val, index, node))
while not priority_queue.empty():
val, index, node = priority_queue.get()
tail.next = node
tail = node
if node.next:
node = node.next
priority_queue.put((node.val, index, node))
return head.next
def mergeTwoLists(l1: ListNode, l2: ListNode) -> ListNode:
if not l2 or not l1:
return l1 or l2
if l1.val > l2.val:
l1, l2 = l2, l1
head = l1
while l1.next and l2:
if l2.val < l1.next.val:
next1, next2 = l1.next, l2.next
l1.next, l2.next = l2, next1
l1, l2 = l2, next2
else:
l1 = l1.next
if l2:
l1.next = l2
return head
def merge(head1: ListNode, head2: ListNode) -> ListNode:
"""归并排序
Args:
head1 (ListNode): 列表1头结点
head2 (ListNode): 列表2头结点
Returns:
ListNode: 合并后的列表
"""
dummy = ListNode(-1)
tmp, tmp1, tmp2 = dummy, head1, head2
while tmp1 and tmp2:
if tmp1.val <= tmp2.val:
tmp.next = tmp1
tmp1 = tmp1.next
else:
tmp.next = tmp2
tmp2 = tmp2.next
tmp = tmp.next
if tmp1:
tmp.next = tmp1
elif tmp2:
tmp.next = tmp2
return dummy.next
def put_even_numbers_before_odd_numbers(self, head):
dummy_even = ListNode(-1)
cur = dummy_even
dummy_odd = ListNode(-1)
cur_odd = dummy_odd
while head:
if head.val % 2 == 0:
cur.next = head
cur = cur.next
else:
cur_odd.next = head
cur_odd = cur_odd.next
head = head.next
# critical: cut ending
cur.next, cur_odd.next = None, None
cur.next = dummy_odd.next
return dummy_even.next
def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
preHead = ListNode(0)
preHead.next = head
cur = preHead
for i in range(0, m - 1):
cur = cur.next
start = cur
cur = cur.next
end = cur
cur = cur.next
for i in range(m, n):
temp = start.next
start.next = cur
cur = cur.next
start.next.next = temp
end.next = cur
return preHead.next
def swapPairs(self, linked_list):
if not linked_list:
return linked_list
head = ListNode(None)
head.next = linked_list
processed_node = head
while processed_node.next:
first_node = processed_node.next
second_node = first_node.next
if not second_node:
return head.next
second_node_next = second_node.next
processed_node.next = second_node
second_node.next = first_node
first_node.next = second_node_next
processed_node = first_node
return head.next
def removeElements(self, head: ListNode, val: int) -> ListNode:
"""
O(n) time
O(n) space => TBD O(1) space
"""
dummyHead = ListNode(0)
p, q = head, dummyHead
while p is not None:
v = p.val
if v == val:
p = p.next
continue # skip it
# Non-skip case
q.next = ListNode(v)
q = q.next
p = p.next
return dummyHead.next
def reverseList(node: ListNode) -> ListNode:
h, prev = node, None
while node:
h = node
next = node.next
node.next = prev
prev = h
node = next
return h
def addTwoNumbers(self, l1, l2):
output = ListNode(0)
carry = 0
dummy = output
while l1 is not None or l2 is not None:
while l1 is not None:
carry += l1.val
l1 = l1.next
while l2 is not None:
carry += l2.val
l2 = l2.next
dummy.next = ListNode(carry % 10)
carry = carry / 10
dummy = dummy.next
return output.next
def make_linked_list_cycle(self, linked_list, position):
if not linked_list or position == -1:
return linked_list
head = ListNode(None)
head.next = linked_list
current_node = head.next
target_node = None
last_node = None
index = 0
while current_node:
if index == position:
target_node = current_node
last_node = current_node
current_node = current_node.next
index += 1
if target_node:
last_node.next = target_node
return head.next
def removeElements(self, head: ListNode, val: int) -> ListNode:
dummy = ListNode(-1, head)
p = dummy
while p.next:
if p.next.val == val:
p.next = p.next.next # 删除节点
else:
p = p.next
return dummy.next
def swapPairs(self, head: ListNode) -> ListNode:
if not head or not head.next:
return head
dummyNode = ListNode(-1)
dummyNode.next = head
first, second = dummyNode, dummyNode.next.next # second 和 first 间隔一个节点
while second:
# 交换节点
tmp = first.next
first.next = second
tmp.next = second.next
second.next = tmp
second = tmp.next.next if tmp.next else None
first = tmp
return dummyNode.next