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")
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))