def main():
l_list = LinkedList()
l_list.generate_list(5, 1, 20)
node = find_node(l_list,3)
print(f'Source List: {l_list}')
delete_nth_node(node)
print(f'Deleted list: {l_list}')
class TestPalindromeList(unittest.TestCase):
"""
Test cases for a Palindrome Linked List
"""
_list_true = LinkedList()
_list_true.add_last(1)
_list_true.add_last(2)
_list_true.add_last(3)
_list_true.add_last(4)
_list_true.add_last(3)
_list_true.add_last(2)
_list_true.add_last(1)
_list_false = LinkedList()
_list_false.add_last(1)
_list_false.add_last(2)
_list_false.add_last(3)
_list_false.add_last(4)
_list_false.add_last(5)
def test_palindrome(self):
_, res = is_palindrome_recurse(self._list_true.head(),
len(self._list_true))
self.assertTrue(res)
def test_not_palindrome(self):
_, res = is_palindrome_recurse(self._list_false.head(),
len(self._list_false))
self.assertFalse(res)
def is_palindrome_stack(l_list: LinkedList):
"""
Implement the algorithm to check if the linked list is a palindrome using a stack
Use the Fast Pointer, Slow pointer technique to insert the first half of the list in the stack,
pop an item off the stack and traverse through the remaining list to see if they match.
1 -> 2 -> 3 -> 4 -> 3 -> 2 -> 1 - True
1 -> 2 -> 3 -> 4 -> 4 -> 3 -> 2 -> 1 - True
:param l_list: Linked list
:return: True if the list is a palindrome, False otherwise
"""
if not l_list or l_list.empty():
return False
# Traverse through the first half of the list and add to the stack
stack = []
slow = l_list.head()
fast = l_list.head()
while fast and fast.next():
stack.append(slow.value())
slow = slow.next()
fast = fast.next().next()
if fast: # If there are odd number of elements in the list, the fast pointer is not null
slow = slow.next()
# Start popping from the stack and compare against the remaining elements in the list using the slow pointer
while slow:
item = stack.pop()
if not item == slow.value():
return False
slow = slow.next()
return True
def main():
l_list = LinkedList()
# l_list.add_last(30)
# l_list.add_last(10)
# l_list.add_last(15)
# l_list.add_last(5)
# l_list.add_last(1)
l_list.generate_list(5, 1, 20)
print(partition(l_list, 7))
def main():
"""
Responsible for creating a linked list and calling remove_dups
:return:
"""
l_list = LinkedList()
l_list.add_to_list([1, 2, 3, 2])
# remove_dups(l_list)
remove_dups_followup(l_list)
print(l_list)
def _sum_list_helper(l1, l2):
if not l1 and not l2:
return 0, None
carry, node = _sum_list_helper(l1.next() if l1 else None,
l2.next() if l2 else None)
node = LinkedList() if not node else node
node_sum = carry + (l1.value() if l1 else 0) + (l2.value() if l2 else 0)
node.add_first(node_sum % 10)
return node_sum // 10, node
def sum_lists(l1, l2, carry):
"""
You have two numbers represented by a linked list, where each node contains a single
digit. The digits are stored in reverse order, such that the 1 's digit is at the head of the list. Write a
function that adds the two numbers and returns the sum as a linked list.
EXAMPLE
Input: (7-> 1 -> 6) + (5 -> 9 -> 2).That is,617 + 295.
Output: 2 -> 1 -> 9. That is, 912.
Input: (8-> 3) + (1 -> 1 -> 2).That is,211 + 38.
Output: 9 -> 4 -> 2. That is, 249.
:param l1: List 1
:param l2: List 2
:param carry: Carry over the sum in the current execution thread
:return:
"""
if not l1 and not l2 and carry == 0:
return
new_list = LinkedList()
node_sum = carry + (l1.value() if l1 else 0) + (l2.value() if l2 else 0)
new_list.add_last(node_sum % 10)
result = sum_lists(l1.next() if l1 else None,
l2.next() if l2 else None, node_sum // 10)
new_list.add_last(result) if result else None
return new_list
def main():
l1 = LinkedList()
# l1.add_last(8)
# l1.add_last(3)
#
# l2 = LinkedList()
# l2.add_last(1)
# l2.add_last(1)
# l2.add_last(2)
#
# new_list = sum_lists(l1.head(), l2.head(), 0)
l1.generate_list(3, 7, 9)
l2 = LinkedList()
l2.generate_list(3, 7, 9)
print(f'List 1 : {l1}')
print(f'List 2 : {l2}')
new_list = sum_lists(l1, l2)
print(new_list)
def main():
l_list = LinkedList()
l_list.generate_list(5, 1, 15)
print(l_list)
# print(kth_to_last(l_list, 3))
kth_to_last_recursive(l_list.head(), 4)
def partition(l_list, part_key):
"""
Write code to partition a linked list around a value x, such that all nodes less than x come
before all nodes greater than or equal to x. If x is contained within the list the values of x only need
to be after the elements less than x (see below). The partition element x can appear anywhere in the
"right partition"; it does not need to appear between the left and right partitions.
:param l_list: Linked List to be partitioned
:param part_key:Key around which the linked list should be partitioned
:return: Reference to the newly created list
"""
if not l_list:
return
left_start = left_end = right_start = None
curr = l_list.head()
left_start = LinkedList()
right_start = LinkedList()
while curr:
if curr.value() < part_key:
left_start.add_last(curr)
else:
right_start.add_last(curr)
curr = curr.next()
if not left_start.empty():
left_end = left_start.tail()
left_end._next = right_start.head()
return left_start if not left_start.empty() else right_start