:type head: Node
:rtype: Node
"""
t = prev = Node(0)
prev.next = head # 0 1 2 3 4
while head and head.next:
prev.next = head.next # 0 2 3 4
head.next = head.next.next # 1 3 4
prev.next.next = head # 0 2 1 3 4
head = head.next # 3 4
prev = prev.next.next # 1 3 4
return t.next
head = generate_nodes([1, 2, 3, 4])
head = swap_pairs(head)
print(traverse_list(head))
def swap_pairs_sol2(head):
if not head or not head.next:
return head
second = head.next
head.next = swap_pairs_sol2(second.next)
second.next = head
return second
head = swap_pairs_sol2(head)
print(traverse_list(head))
def merge_k_lists(lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
head = point = Node(0)
q = PriorityQueue()
for l in lists:
q.put((l.val, id(l), l))
while not q.empty():
# get the lowest from queue
val, _id, node = q.get()
point.next = Node(val)
point = point.next
node = node.next
if node:
q.put((node.val, id(node), node))
return head.next
head_1 = generate_nodes([1, 4, 5])
head_2 = generate_nodes([1, 3, 4])
head_3 = generate_nodes([2, 6])
head_4 = generate_nodes([1, 1])
o = merge_k_lists([head_1, head_2, head_3, head_4])
print(traverse_list(o))
def test_1(self):
l1 = generate_nodes([1, 2, 4])
l2 = generate_nodes([1, 3, 4])
output = merge_two_lists(l1, l2)
self.assertEqual(traverse_list(output), [1, 1, 2, 3, 4, 4])
def test_1(self):
l1 = generate_nodes([1, 2])
output = swap_pairs(l1)
self.assertEqual(traverse_list(output), [2, 1])
def test_2(self):
l1 = generate_nodes([])
l2 = generate_nodes([])
output = merge_two_lists(l1, l2)
self.assertEqual(traverse_list(output), [])
def test_1(self):
arr1 = generate_nodes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
out = remove_nth_frm_end(arr1, 4)
self.assertEqual(traverse_list(out), [1, 2, 3, 4, 5, 6, 8, 9, 10])
def test_4(self):
arr1 = generate_nodes([1, 2, 3, 4])
out = remove_nth_frm_end(arr1, 4)
self.assertEqual(traverse_list(out), [2, 3, 4])
def remove_nth_frm_end(head, n):
"""
2 pointer algo
:type head: ListNode
:type n: int
:rtype: ListNode
"""
tmp = Node(-1)
tmp.next = head
pointer_1 = tmp
pointer_2 = tmp
# Move over n nodes including dummy
for i in range(n):
pointer_2 = pointer_2.next # set pointer_2 to n-1 th
# Increment ptrs till you reach end of list
while pointer_2.next:
pointer_1 = pointer_1.next
pointer_2 = pointer_2.next
# Now pointer_1.next points to the nth node from the end
pointer_1.next = pointer_1.next.next
return head
hea = remove_nth_frm_end(generate_nodes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 4)
print(traverse_list(hea))
"""
Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.
Example:
Input: 1->2->4, 1->3->4
Output: 1->1->2->3->4->4
"""
from linked_list.LinkedList import generate_nodes, traverse_list, Node
head_1 = generate_nodes([1, 2, 4])
head_2 = generate_nodes([1, 3, 4])
def merge_two_lists(l1, l2):
"""
:type l1: Head Node 1 : 1, 2, 4
:type l2: Head Node 2 : 1, 3, 4
:rtype: ListNode 1->1->2->3->4->4
"""
if not l1 or not l2:
return l1 or l2
if l1.val < l2.val:
l1.next = merge_two_lists(l1.next, l2)
return l1
else:
l2.next = merge_two_lists(l1, l2.next)
return l2