def reverse(llist: LinkedList) -> LinkedList:
"""
Reverses a singly LinkedList without a tail by
returning a new reversed LinkedList.
"""
new_list = LinkedList()
current_node = llist.head
new_list.head = Node(current_node.value)
while current_node:
current_node = current_node.next
if current_node:
new_node = Node(current_node.value)
new_node.next = new_list.head
new_list.head = new_node
return new_list
def main():
# Create linked list :
# 10->20->30->40->50
list1 = LinkedList()
list1.append(10)
list1.append(20)
list1.append(30)
list1.append(40)
list1.append(50)
print("Printing List1:")
list1.print_list()
# Create linked list 2 :
# 5->15->18->35->60
list2 = LinkedList()
list2.append(5)
list2.append(15)
list2.append(18)
list2.append(35)
list2.append(60)
print("Prining List2:")
list2.print_list()
# Create linked list 3
list3 = LinkedList()
# Merging linked list 1 and linked list 2
# in linked list 3
list3.head = merge_ll(list1.get_head(), list2.get_head())
print(" Merged Linked List is : ", end="")
list3.print_list()
def merge(left, right):
"""
Merges two linked lists sorting by data in nodes
Returns a new, merge list
Takes O(n) time
"""
# Create a new linked list that contains nodes from
# merging left and right
merged = LinkedList()
# Add a fake head that is discarded later
merged.add(0)
# Set current to the head of the linked list
current = merged.head
# Obtain head nodes for left and right linked list
right_head = right.head
left_head = left.head
# Iterate over left and right until we reach the tail node of either
while left_head or right_head:
# If the head node of left is None, we're past the tail
# Add the node from right to merged linked list
if left_head is None:
current.next_node = right_head
# Call next on right to set loop condition to false
right_head = right_head.next_node
# If the head node of right is None, We're past the tail
# Add the tail node from left to merged linked list
elif right_head is None:
current.next_node = left_head
# Call next on left to set loop condition to false
left_head = left_head.next_node
else:
# Not at either tail node
# Obtain node data to perform comparison operations
left_data = left_head.data
right_data = right_head.data
# If data on left is less than right, set current to left node
if left_data < right_data:
current.next_node = left_head
# Move left head to next node
left_head = left_head.next_node
# If data on left is greater than right, set current to right node
else:
current.next_node = right_head
# Move right head to next node
right_head = right_head.next_node
# Move current to next node
current = current.next_node
# Discard fake head and set first merge node as head
head = merged.head.next_node
merged.head = head
return merged
def split(linked_list):
"""
Divide the unsorted list at midpoint into sublist
Takes O(k log n) time
"""
if linked_list is None or linked_list.head is None:
left_half = linked_list
right_half = None
return left_half, right_half
else:
size = linked_list.size()
mid = size // 2
mid_node = linked_list.node_at_index(mid - 1)
left_half = linked_list
right_half = LinkedList()
right_half.head = mid_node.next_node
mid_node.next_node = None
return left_half, right_half
temp = reverse_linked_list_recursion(head.next)
# Assume all nodes after the current node's next node are all
# reversed, now we need to reverse the next node and the
# current node.For example, when 3 is returned, temp will be 3,
# while head will be 2, and 2.next.next is now assigned to 2
# which means 3.next = 2, so the node is reversed.
head.next.next = head
# To avoid a list loop, we need to set head.next to None, in
# this case, 2.next is set to None for now.
head.next = None
# Return the last node or the first node in the reversed list.
# Here it's 3.
return temp
if __name__ == "__main__":
new_list = LinkedList([1,2,3,4,5,6])
print(f"Linked List: {new_list}")
new_head = reverse_linked_list(new_list.head)
reversed_list = LinkedList()
reversed_list.head = new_head
print(f"Linked List: {reversed_list}")
new_list = LinkedList([1,2,3,4,5,6])
print(f"Linked List: {new_list}")
reversed_head = reverse_linked_list_recursion(new_list.head)
new_reversed_list = LinkedList()
new_reversed_list.head = reversed_head
print(f"Linked List: {new_reversed_list}")
if prevX == None:
head = currY
else:
prevX.next = currY
# If y is head // make x as the new head
if prevY == None:
head = currX
else:
prevY.next = currX
# Swap next pointers
temp = currX.next
currX.next = currY.next
currY.next = temp
return head
if __name__ == '__main__':
l = LinkedList()
l.append_node("A")
l.append_node("B")
l.append_node("C")
l.append_node("D")
l.traverse()
l.head = swap_node(l.head, 'A', 'C')
l.traverse()
# If linkedlist has only one node
if head.next == None:
return head
# If linkedlist has more than one nodes
front = head.next.next
back = head
head = head.next
back.next = None
while front != None:
head.next = back
back = head
head = front
front = front.next
head.next = back
return head
if __name__ == '__main__':
l = LinkedList()
l.append_node("A")
l.append_node("B")
l.append_node("C")
l.traverse()
l.head = reverseLinkedList(l.head)
l.traverse()
