def is_palindrome(linkedlist):
first_runner = linkedlist.head
second_runner = first_runner.next
reverse_half = SingleLinkedList()
while first_runner:
if second_runner.next is None:
temp_node = Node(first_runner.data)
temp_node.next = reverse_half.head
reverse_half.head = temp_node
elif second_runner.next.next is None:
second_runner = second_runner.next
else:
second_runner = second_runner.next.next
first_runner = first_runner.next
current_node = linkedlist.head
check_node = reverse_half.head
while check_node:
if check_node.data == current_node.data:
check_node = check_node.next
current_node = current_node.next
else:
return False
return True
def setUp(self):
self.sll = SingleLinkedList()
self.sll.append(10)
self.sll.append(9)
self.sll.append(9)
self.sll.append(5)
self.sll.append(1)
def sum_lists(list1, list2):
result = SingleLinkedList()
list1_node = list1.head
list2_node = list2.head
carry = 0
while list1_node and list2_node:
sum = list1_node.data + list2_node.data + carry
carry = sum // 10
result.append(sum % 10)
list1_node = list1_node.next
list2_node = list2_node.next
if list1_node is None and list2_node:
while list2_node:
sum = list2_node.data + carry
result.append(sum % 10)
list2_node = list2_node.next
elif list2_node is None and list1_node:
while list1_node:
sum = list1_node.data + carry
result.append(sum % 10)
list1_node = list1_node.next
elif list2_node is None and list1_node is None and carry:
result.append(carry)
return result
def test_delete_middle_node(self):
sll = SingleLinkedList()
sll.append(10)
sll.append(9)
sll.append(9)
sll.append(5)
sll.append(1)
delete_middle_node(sll)
self.assertEqual(sll.values(), "10 -> 9 -> 5 -> 1 -> None")
delete_middle_node(sll)
self.assertEqual(sll.values(), "10 -> 5 -> 1 -> None")
def test_get_value(self):
sll = SingleLinkedList()
sll.append(10)
sll.append(9)
sll.append(9)
sll.append(5)
sll.append(1)
self.assertEqual(get_value_to_last(sll, 3), 9)
self.assertEqual(get_value_to_last(sll, 2), 5)
class Stack(object):
instance1st = SingleLinkedList()
def pop(self):
return self.instance1st.removeAt(0)
def push(self, value):
self.instance1st.insertAt(value, 0)
def sum_lists_by_converting(list1, list2):
list1_node = list1.head
list2_node = list2.head
result = SingleLinkedList()
converted_list1 = []
converted_list2 = []
while list1_node:
converted_list1.insert(0, list1_node.data)
list1_node = list1_node.next
while list2_node:
converted_list2.insert(0, list2_node.data)
list2_node = list2_node.next
sum = str(int(''.join(map(str, converted_list1))) + int(''.join(map(str, converted_list2))))
for i in range(len(sum)-1, -1, -1):
result.append(int(sum[i]))
return result
class Queue:
instance1st = SingleLinkedList()
def enqueue(self, value):
self.instance1st.insertAt(value, self.instance1st.getSize())
def dequeue(self):
dequeueValue = self.instance1st.get(0)
self.instance1st.removeAt(0)
return dequeueValue
class Test(unittest.TestCase):
def setUp(self):
self.sll = SingleLinkedList()
self.sll.append(10)
self.sll.append(1)
self.sll.append(9)
self.sll.append(5)
self.sll.append(2)
def test_partition(self):
partition_by_value(self.sll, 5)
self.assertEqual(self.sll.values(), "1 -> 2 -> 10 -> 9 -> 5 -> None")
def test_partition_in_place(self):
partition_in_place(self.sll, 5)
self.assertEqual(self.sll.values(), "2 -> 1 -> 10 -> 9 -> 5 -> None")
def partition_by_value(linkedlist, partition):
left_list = SingleLinkedList()
right_list = SingleLinkedList()
current_node = linkedlist.head
while current_node is not None:
if current_node.data < partition:
left_list.append(current_node.data)
else:
right_list.append(current_node.data)
current_node = current_node.next
left_node = left_list.head
while left_node.next is not None:
left_node = left_node.next
left_node.next = right_list.head
linkedlist.head = left_list.head
def remove_duplicates(lst):
memo = {}
if lst.is_empty():
return lst
p = lst.get_head()
unique_list = SingleLinkedList()
while p is not None:
if p.data not in memo:
memo[p.data] = p.data
insert_at_tail(unique_list, p.data)
p = p.next_element
return unique_list
def setUp(self):
self.sll_1 = SingleLinkedList()
self.sll_1.append(7)
self.sll_1.append(1)
self.sll_1.append(6)
self.sll_2 = SingleLinkedList()
self.sll_2.append(5)
self.sll_2.append(9)
self.sll_2.append(2)
self.sll_3 = SingleLinkedList()
self.sll_3.append(9)
self.sll_3.append(7)
self.sll_3.append(8)
self.sll_4 = SingleLinkedList()
self.sll_4.append(6)
self.sll_4.append(8)
self.sll_4.append(5)
def partition(sll, x):
new_sll = SingleLinkedList()
cur = sll.head
while cur is not None:
if cur.value < x:
new_sll.insert_start(cur.value)
else:
new_sll.insert_end(cur.value)
cur = cur.next
return new_sll
def sum_ll(ll1, ll2):
ll3 = SingleLinkedList()
cur1 = ll1.head
cur2 = ll2.head
cary = 0
while cur1 is not None and cur2 is not None:
sum_ = cur1.value + cur2.value + cary
res = sum_ % 10
ll3.insert_end(res)
cary = sum_ // 10
cur1 = cur1.next
cur2 = cur2.next
ll3.insert_end(cary)
return ll3
def sum_ll(ll1, ll2):
ll3 = SingleLinkedList()
cur1 = ll1.head
cur2 = ll2.head
cary = 0
while cur1 is not None and cur2 is not None:
sum_ = cur1.value + cur2.value + cary
res = sum_ % 10
ll3.insert_end(res)
cary = sum_ // 10
cur1 = cur1.next
cur2 = cur2.next
ll3.insert_end(cary)
return ll3
if __name__ == '__main__':
# Lets create Linked Lists for n1 = 789 & n2 = 211
n1 = 789
n2 = 211
ll1 = SingleLinkedList()
ll2 = SingleLinkedList()
for i in split_digits(n1):
ll1.insert_end(i)
for i in split_digits(n2):
ll2.insert_end(i)
print(ll1) # 9->8->7
print(ll2) # 1->1->2
ll3 = sum_ll(ll1, ll2)
print(ll3) # 0->0->0->1
from SingleLinkedList import SingleLinkedList l = SingleLinkedList() l.insert_head(10) print(l) l.insert_head(20) l.insert_head(30) print(l) l.insert_tail(40) print(l) print(l.list_size()) l.insert_tail(50) print(l) print(l.find_head()) print(l.find_tail()) print(l) print(l.delete_head()) print(l) print(l.list_size()) print(l.delete_tail()) print(l) print(l.list_size()) print(l.delete_tail()) print(l.delete_tail()) print(l.delete_tail()) print(l.delete_tail()) print(l.list_size())
"""
def partition(sll, x):
new_sll = SingleLinkedList()
cur = sll.head
while cur is not None:
if cur.value < x:
new_sll.insert_start(cur.value)
else:
new_sll.insert_end(cur.value)
cur = cur.next
return new_sll
if __name__ == '__main__':
"""
OutPut:
Original LinkedList is 8->7->1->6->2->1
Partitioned linkedList around 6 is:1->2->1->8->7->6
"""
# Lets create SLL
ll = [1, 2, 6, 1, 7, 8]
sll = SingleLinkedList()
for i in ll:
sll.insert_start(i)
print(f'Original LinkedList is {sll}') # 8->7->1->6->2->1
partition_value = 6
new_ssl = partition(sll, partition_value)
print(f'Partitioned linkedList around {partition_value} is:{new_ssl} ')
def main():
# creates the linked list with three data elements
newlist = SingleLinkedList()
newlist.head = Node("Mon")
element2 = Node("Tue")
element3 = Node("Wed")
# Link first Node to second node, Link second Node to third node
newlist.head.next = element2
element2.next = element3
"""Traversing a Linked List"""
newlist.traverse()
"""Insertion in a Linked List"""
print("\n")
newlist.insertion_begin("Sun")
newlist.traverse()
print("\n")
newlist.insertion_end("Thu")
newlist.traverse()
print("\n")
newlist.insertion_between(newlist.head.next, "Fri")
newlist.traverse()
"""Removing an Item form a Liked List"""
print("\n")
newlist.remove("Wed")
newlist.traverse()
class Test(unittest.TestCase):
def setUp(self):
self.sll_1 = SingleLinkedList()
self.sll_1.append(7)
self.sll_1.append(1)
self.sll_1.append(6)
self.sll_1.append(1)
self.sll_1.append(7)
self.sll_2 = SingleLinkedList()
self.sll_2.append(7)
self.sll_2.append(1)
self.sll_2.append(6)
self.sll_2.append(6)
self.sll_2.append(1)
self.sll_2.append(7)
self.sll_3 = SingleLinkedList()
self.sll_3.append(7)
self.sll_3.append(1)
self.sll_3.append(5)
self.sll_3.append(6)
self.sll_3.append(1)
self.sll_3.append(7)
def test_is_palindrome(self):
self.assertTrue(is_palindrome(self.sll_1))
self.assertTrue(is_palindrome(self.sll_2))
self.assertFalse(is_palindrome(self.sll_3))
def test_is_palindrome_with_stack(self):
self.assertTrue(is_palindrome_with_stack(self.sll_1))
self.assertTrue(is_palindrome_with_stack(self.sll_2))
self.assertFalse(is_palindrome_with_stack(self.sll_3))
def test_is_palindrome_recursively(self):
self.assertTrue(is_palindrome_recursively(self.sll_1))
self.assertTrue(is_palindrome_recursively(self.sll_2))
self.assertFalse(is_palindrome_recursively(self.sll_3))
from SingleLinkedList import SingleLinkedList
from Stack import Stack
from Queue import Queue
from HashMap import HashMap
list = SingleLinkedList()
list.addNode("Jason")
list.addNode("Tristan")
list.addNode("Albert")
list.addNode("Jax")
list.printList()
print("******stack********")
stack = Stack()
stack.addNode("Jason")
stack.addNode("Tristan")
stack.addNode("Albert")
stack.addNode("Jax")
stack.printList()
stack.pop()
print("**pop**")
stack.printList()
print("*******queue********")
queue = Queue()
queue.addNode("Jason")
queue.addNode("Tristan")
queue.addNode("Albert")
queue.addNode("Jax")
queue.printList()
print("**pop**")
def __init__(self):
SingleLinkedList.__init__(self)
def test_sum_lists_by_recursion(self):
result_list = SingleLinkedList()
result_list.head = sum_lists_by_recursion(self.sll_1.head, self.sll_2.head, 0)
self.assertEqual(result_list.values(), "2 -> 1 -> 9 -> None")
result_list.head = sum_lists_by_recursion(self.sll_3.head, self.sll_4.head, 0)
self.assertEqual(result_list.values(), "5 -> 6 -> 4 -> 1 -> None")
class Test(unittest.TestCase):
def setUp(self):
self.sll_1 = SingleLinkedList()
self.sll_1.append(7)
self.sll_1.append(1)
self.sll_1.append(6)
self.sll_2 = SingleLinkedList()
self.sll_2.append(5)
self.sll_2.append(9)
self.sll_2.append(2)
self.sll_3 = SingleLinkedList()
self.sll_3.append(9)
self.sll_3.append(7)
self.sll_3.append(8)
self.sll_4 = SingleLinkedList()
self.sll_4.append(6)
self.sll_4.append(8)
self.sll_4.append(5)
def test_sum_lists(self):
self.assertEqual(sum_lists(self.sll_1, self.sll_2).values(), "2 -> 1 -> 9 -> None")
self.assertEqual(sum_lists(self.sll_3, self.sll_4).values(), "5 -> 6 -> 4 -> 1 -> None")
def test_sum_lists_by_converting(self):
self.assertEqual(sum_lists_by_converting(self.sll_1, self.sll_2).values(), "2 -> 1 -> 9 -> None")
self.assertEqual(sum_lists_by_converting(self.sll_3, self.sll_4).values(), "5 -> 6 -> 4 -> 1 -> None")
def test_sum_lists_by_recursion(self):
result_list = SingleLinkedList()
result_list.head = sum_lists_by_recursion(self.sll_1.head, self.sll_2.head, 0)
self.assertEqual(result_list.values(), "2 -> 1 -> 9 -> None")
result_list.head = sum_lists_by_recursion(self.sll_3.head, self.sll_4.head, 0)
self.assertEqual(result_list.values(), "5 -> 6 -> 4 -> 1 -> None")
print 'm must be greater than 1'
first = L.head
i = 0
while i < m and first != None:
first = first.next
i = i + 1
if i < m-1 or (i == m-1 and first == None):
print 'list length < %d' % m
return
lastm = L.head
while first != None:
first = first.next
lastm = lastm.next
print lastm.val
l = SingleLinkedList()
l.addFirst(1)
l.addFirst(0)
l.addFirst(3)
l.addFirst(5)
l.addLast(4)
l.printList()
findLastM(l, 1)
findLastM(l, 2)
findLastM(l, 5)
findLastM(l, 6)
findLastM(l, 8)
def single_linked_list_test():
s = SingleLinkedList()
s.add_node_at_first(LinkedListNode(4))
s.add_node_at_first(LinkedListNode(5))
s.add_node_at_first(LinkedListNode(7))
s.add_node_at_last(LinkedListNode(6))
s.add_node_at_last(LinkedListNode(9))
print("before delete")
s.traverse()
s.delete_node(LinkedListNode(4))
print("after delete")
print("first.... %s" % s.get_first().get_data())
print("last....%s " % s.get_last().get_data())
print("size.....%d" % s.get_size())
s.traverse()
class Test(unittest.TestCase):
def setUp(self):
self.sll = SingleLinkedList()
self.sll.append(10)
self.sll.append(9)
self.sll.append(9)
self.sll.append(5)
self.sll.append(1)
def test_append(self):
self.assertEqual(self.sll.values(), "10 -> 9 -> 9 -> 5 -> 1 -> None")
def test_remove(self):
self.sll.remove(5)
self.assertEqual(self.sll.values(), "10 -> 9 -> 9 -> 1 -> None")
def test_remove_duplicates(self):
remove_duplicates(self.sll)
self.assertEqual(self.sll.values(), "10 -> 9 -> 5 -> 1 -> None")
def test_remove_duplicates_without_buffer(self):
remove_duplicates_without_buffer(self.sll)
self.assertEqual(self.sll.values(), "10 -> 9 -> 5 -> 1 -> None")
def single_linked_list_test():
s = SingleLinkedList()
s.add_node_at_first(LinkedListNode(4))
s.add_node_at_first(LinkedListNode(5))
s.add_node_at_first(LinkedListNode(7))
s.add_node_at_last(LinkedListNode(6))
s.add_node_at_last(LinkedListNode(9))
print("before delete")
s.traverse()
s.delete_node(LinkedListNode(4))
print("after delete")
print("first.... %s" % s.get_first().get_data())
print("last....%s " % s.get_last().get_data())
print("size.....%d" % s.get_size())
s.traverse()
import time
import random
from SingleLinkedList import SingleLinkedList
TIME_TO_WAIT = 12
new_linked_list = SingleLinkedList()
# Appending new values to the linked list
print("Appending new values...")
python_list = []
for i in range(0, 10):
random_intger = random.randint(1, 101)
python_list.append(random_intger)
new_linked_list.append(random_intger)
# Getting all values
values_of_linked_list: list = new_linked_list.get_all_values()
print("Values of the linked list:")
print(values_of_linked_list)
# Finding the lenght of the linked list
print("Let's find the length of our linked list")
time.sleep(TIME_TO_WAIT)
print(new_linked_list.length())
# Getting value from linked list
print("Now let's find the value of node with index 4!")
time.sleep(TIME_TO_WAIT)
if lst.is_empty():
return lst
p = lst.get_head()
unique_list = SingleLinkedList()
while p is not None:
if p.data not in memo:
memo[p.data] = p.data
insert_at_tail(unique_list, p.data)
p = p.next_element
return unique_list
l = SingleLinkedList()
# l.insert_at_head(1)
# l.insert_at_head(2)
# l.insert_at_head(3)
# l.insert_at_head(4)
# l.insert_at_head(5)
# l.print_list()
insert_at_tail(l, 1)
insert_at_tail(l, 2)
insert_at_tail(l, 2)
insert_at_tail(l, 3)
insert_at_tail(l, 4)
insert_at_tail(l, 4)
# l.print_list()
# print(search(l, 4)) # returns a node
# print(recursive_search(l.head_node, 3))
