def test_init(self): data = 'ABC' node = Node(data) # Initializer should add instance properties assert node.data is data assert node.next is None assert node.prev is None
def append(self, item, number_of_columns=0): """Insert the given item at the tail of this linked list. TODO: Running time: O(1) Why and under what conditions?""" # TODO: Create new node to hold given item node = Node(item) if type(item) is list: node.data = LinkedList(node.data) # TODO: Append node after tail, if it exists if self.tail is None: self.head = node self.tail = node else: self.tail.next = node self.tail = node else: # start from first column columns = 0 for node in self: if columns == number_of_columns: linkedlist = node.data linkedlist.append(item) break else: # count columns columns += 1
def test_remove_not_exisiting(self): head = Node(5) linked = LinkedList(head) linked.append(9) node = linked.remove(7) self.assertEqual(node, None, 'should be None') self.assertEqual(str(linked), '5->9', 'should be 5->9')
def push(self, value): if self.has_space(): item = Node(value) item.set_next_node(self.top_item) self.top_item = item self.size += 1 else: print("No more room on stack")
def sum_lists(num1, num2): if num1 is None or num2 is None: return num1 or num2 carry = 0 # We use a dummy node as the head of the sum list. # We can also set the head as None. # But this needs more if-else checks as we move head through the list using head.next as None has no next parameter. head = new_head = Node(0) while num1 is not None or num2 is not None: # caution: don't forget to check for None if num1 is None: num1_value = 0 else: num1_value = num1.value if num2 is None: num2_value = 0 else: num2_value = num2.value num_sum = carry + num1_value + num2_value if num_sum >= 10: carry = 1 num_sum = num_sum % 10 else: carry = 0 current = Node(num_sum) head.next = current head = head.next # caution: don't forget to check for None if num1 is not None: num1 = num1.next if num2 is not None: num2 = num2.next if carry > 0: current.next = Node(carry) return new_head.next
def test_sum_lists(self): head1 = Node(5) head1.next = Node(8) head1.next.next = Node(7) head2 = Node(3) head2.next = Node(8) result_sum = sum_lists(head1, head2) self.assertEqual(result_sum.value, 8) self.assertEqual(result_sum.next.value, 6) self.assertEqual(result_sum.next.next.value, 8) head3 = None head4 = None result_sum2 = sum_lists(head3, head4) self.assertEqual(result_sum2, None)
def add_node_at_depth(t, depth=0): if t is BinaryTree.empty: return if depth not in depths: depths[depth] = Node.empty depths[depth] = Node(t.label, depths[depth]) add_node_at_depth(t.left, depth + 1) add_node_at_depth(t.right, depth + 1)
def test_search_not_existing(self): head = Node(5) linked = LinkedList(head) linked.append(7) linked.append(11) node = linked.search(15) self.assertEqual(node, None, 'should be None') self.assertEqual(str(linked), '5->7->11', 'should be 5->7->11')
def test_length(): print("------TEST LENGTH------") s_list = LinkedList() s_list.add_in_tail(Node(12)) s_list.add_in_tail(Node(55)) s_list.add_in_tail(Node(128)) s_list.add_in_tail(Node(55)) s_list.add_in_tail(Node(130)) s_list.print_all_nodes() try: print(s_list.len()) if s_list.len() == 5: print("test length success") else: print("test lenght failed") except Exception: print("error test lenght")
def main(): ll = LinkedList() data = [char for char in 'FOLLOW UP'] for char in data[::-1]: node = Node(char) ll.insert(node) remove_duplicates(ll.head) print "%s" % ll == "%s" % ['F', 'O', 'L', 'W', ' ', 'U', 'P']
def setUp(self): self.head1 = Node(1) self.head2 = Node(1) self.head2.next = Node(2) self.head2.next.next = Node(5) self.head2.next.next.next = Node(2) self.head2.next.next.next.next = Node(1) self.head3 = Node(1) self.head3.next = Node(2) self.head4 = None
def test_partition(self): head = Node(5) head.next = Node(3) head.next.next = Node(1) head.next.next.next = Node(2) head.next.next.next.next = Node(4) head2 = None result_head = partition(head, 3) self.assertEqual(result_head.value, 1) self.assertEqual(result_head.next.value, 2) self.assertEqual(result_head.next.next.value, 5) self.assertEqual(result_head.next.next.next.value, 3) self.assertEqual(result_head.next.next.next.next.value, 4) result_head2 = partition(head2, 3) self.assertEqual(result_head2, None)
def test_pop_two(self): head = Node(5) linked = LinkedList(head) linked.append(7) node = linked.pop() self.assertEqual(node.val, 7, 'should be 7') node = linked.pop() self.assertEqual(node.val, 5, 'should be 5') self.assertEqual(str(linked), '', 'should be empty')
def main(): ll = LinkedList() data = [char for char in '123456789'] for char in data[::-1]: node = Node(char) ll.insert(node) print ll print ll.size() print kth_tolast(ll.head, 5).val == '123456789'[-5]
def set_up(l1, l2): intersecting_node = Node(5) intersecting_node.next = Node(6) intersecting_node.next.next = Node(7) l1tail = l1.head l2tail = l2.head while l1tail.next is not None: l1tail = l1tail.next l1tail.next = intersecting_node while l2tail.next is not None: l2tail = l2tail.next l2tail.next = intersecting_node
def test_linking_nodes(self): node1 = Node('A') node2 = Node('B') node3 = Node('C') # Link nodes together node1.next = node2 node1.prev = None node2.next = node3 node2.prev = node1 node3.prev = node2 node3.next = None # Node links should be transitive assert node1.prev is None assert node1.next is node2 # One link assert node2.prev is node1 assert node1.next.next is node3 # Two links assert node3.prev is node2 assert node3.next is None
def setUp(self): self.head1 = Node(1) self.head1.next = Node(3) self.head1.next.next = Node(6) self.head1.next.next.next = Node(5) self.loop_node = Node(3) self.head2 = Node(1) self.head2.next = self.loop_node self.head2.next.next = Node(6) self.head2.next.next.next = Node(5) self.head2.next.next.next.next = Node(4) self.head2.next.next.next.next.next = self.loop_node self.head3 = None self.head4 = Node(1) self.head4.next = None
def create_transactions(): global local_clock global bchain global time_table while True: print(bchain) print(colored(f"\n\n(alert) This client ID is {PORT}.", 'cyan')) print( "What type of transaction do you want to issue?\n\t1. Transfer\n\t2. Balance\n\t3. Send Sync" ) option = int(input()) if option == 1: # update the clock for each transaction local_clock[CLIENT_ID] += 1 print("Enter the Reciever ID: ") reciever = int(input()) print("Enter the amount you wish to send: ") amount = float(input()) print( colored( f"(message) You {PORT} are sending {amount} to {reciever}, clock: {local_clock[CLIENT_ID]}", 'yellow')) if calculateBalance(bchain, INIT_BAL, PORT) >= amount: transaction = Node(PORT, reciever, amount, local_clock[CLIENT_ID]) bchain.append(transaction) print(colored("(response) SUCCESS", 'green')) else: print(colored("(response) INCORRECT", 'red')) local_clock[CLIENT_ID] -= 1 elif option == 2: # this should be simple since there is no need to check or make any request to other clients print(colored(f"(message) Checking balance for {PORT}.", 'yellow')) balance = calculateBalance(bchain, INIT_BAL, PORT) print(colored(f"(response) The balance is: ${balance}.", 'green')) for client in CLIENTS: balance = calculateBalance(bchain, INIT_BAL, client) print( colored( f"(response) The estimated balance for {client} is: ${balance}.", 'green')) elif option == 3: print("Enter the Reciever ID: ") reciever = int(input()) msg = build_msg(reciever) send_sync = threading.Thread(name="Send sync message thread", target=send_to_clients, args=(msg, reciever)) send_sync.start() send_sync.join() else: print(colored("Incorrect transaction type.", 'yellow')) update_clock(local_clock, CLIENT_ID) print(colored(f"(message) Clock: {local_clock}", 'yellow')) print(colored(f"(message) Updated TT for {CLIENT_ID}", 'yellow')) print(colored(f"(message) TT: {time_table}", 'yellow'))
def insert(self, value): node = Node(value) node.next = None if self.length == 0: self.head = self.last = node else: last = self.last last.next = node self.last = node self.length += 1
def setUp(self): """Create a test linked list""" myllhead = Node(1) myllhead.append(2) myllhead.append(2) myllhead.append(3) myllhead.append(3) self.myllhead = myllhead
def sum_lists(ll1, ll2, reverse=True): if reverse: head1 = ll1 head2 = ll2 current1 = head1 current2 = head2 carry = 0 prev = None while current1 is not None: if current2 is not None: sm = current1.value + current2.value + carry carry, current1.value = sm // 10, sm % 10 prev = current1 current1, current2 = current1.next, current2.next while current2 is not None: prev.next = Node() current1 = prev.next current1.value = current2.value + carry prev = current2 current2 = current2.next if carry != 0: prev.next = Node() prev.next.value = carry return head1 else: ll1_str = '' ll2_str = '' while ll1 is not None: ll1_str += str(ll1.value) ll1 = ll1.next while ll2 is not None: ll2_str += str(ll2.value) ll2 = ll2.next result_str = str(int(ll1_str) + int(ll2_str)) return create_linkedlist(result_str)
def main1(): """ open the file and read the file""" file = open('file1', 'r') lines_of_file = file.readlines() for singl in lines_of_file: words = singl.lower().split() for word in words: first = Node(word) """Inserting the element into linked list""" obj.insert(first) print("The word in the linked list--->") obj.traverse() """Taking input from user the element to be searched""" search1 = input(("Enter the word you want to search in the list:")) if obj.search(search1): """ If search word is found then deleting this word from file as well as from linked list""" obj.delete_word(search1) """Deleting word from file by over writting .""" f = open("file1", 'w') f.write("") f.close() length = obj.len() f = open('file1', 'a+') for i in range(0, length): f.write(" " + obj.index(i)) f.close() print("The word you searched is deleted :") else: """The search element is not found then adding the element into Linkedlist as well as into the file""" add_word = Node(search1) obj.insert(add_word) f = open('file1', 'a+') f.write(" " + search1) f.close() print("The word you search is added to the list:") print("After the searching the word your list is updated!!") obj.traverse()
def assgin(self, key, value): array_index = self.compress(self.hash(key)) # self.array[array_index] = [key, value] list_at_index = self.array[array_index] payload = Node([key, value]) for item in list_at_index: if item[0] == key: item[1] = value return list_at_index.insert(payload)
def test_clean(): print("------TEST CLEAN------") s_list = LinkedList() s_list.add_in_tail(Node(12)) s_list.add_in_tail(Node(55)) s_list.add_in_tail(Node(128)) s_list.add_in_tail(Node(55)) s_list.add_in_tail(Node(130)) s_list.print_all_nodes() print("---------------") try: s_list.clean() s_list.print_all_nodes() if s_list.head == None and s_list.tail == None: print("test for clean success") else: print("test for clean failed") except Exception: print("error test clean")
def enqueue(self, item): """Insert the given item at the back of this queue. Running time: O(???) – Why? [TODO]""" new_node = Node(item) try: self.tail.next = new_node except AttributeError: # queue is empty self.head = new_node self.tail = new_node self.tail = new_node
def is_anagram_by_comparison(s1, s2): # check if len match. for each char in s1, check if matching in s2. if len(s1) != len(s2): return False if len(s2) == 0: return True # turn s2 into ll for easy removal it = iter(s2) ll = LinkedList(Node(next(it))) for c in it: ll.append(Node(c)) # for each char in string1, remove from string2 if exist for c in s1: if ll.remove(c) < 0: return False return True
def contract(ll: LinkedList,head,other): #print(f"linkedlist is {ll}") prevnode=ll.head for elem in ll: if ll.head.data==head: if elem.data==other: ll.remove_node(targetnode_data=other) elif ll.head.data==other: if elem.data==head: ll.remove_node(targetnode_data=head) ll.remove_node(targetnode_data=other) ll.add_first(node=Node(head)) else: if elem.data==other: ll.add_after(targetnode=other,newnode=Node(head)) ll.remove_node(targetnode_data=other) prevnode=elem
def push(self, item): """Insert the given item on the top of this stack. Running time: O(1) because we only have to reassign the head pointer which does not depend on the number of items in the list """ new_node = Node(item) self.list.size += 1 # increment size if self.list.head is None: # case where list is empty self.list.head = new_node return new_node.next = self.list.head self.list.head = new_node
def partation(ll, K): """ Kの大きさで分割して並び替えたものを返す。 """ n = ll left, right = Node(), Node() while True: if n.data < K: left.appendToTail(n.data) else: right.appendToTail(n.data) if n.next == None: break n = n.next # これだと宣言の関係上一番始めがNoneになっているのでとりのぞいてから連結する right = right.get_Nth_node(1) left = left.get_Nth_node(1) left.appendNodeToTail(right) return left
def test_insert(): print("------TEST INSERT------") s_list = LinkedList() n1 = Node(12) n2 = Node(55) n3 = Node(128) n4 = Node(55) n5 = Node(130) n1.next = n2 n2.next = n3 n3.next = n4 n4.next = n5 s_list.add_in_tail(n1) s_list.add_in_tail(n2) s_list.add_in_tail(n3) s_list.add_in_tail(n4) s_list.add_in_tail(n5) s_list.print_all_nodes() print("---------------") try: nnew = Node(1001) s_list.insert(n2, nnew) s_list.print_all_nodes() print("head", s_list.head, s_list.head.value) print("tail", s_list.tail, s_list.tail.value) node = s_list.head count = 0 while node != None: if node.value == 55 and node.next.value == 1001: count = count + 1 if node.value == 1001 and node.next.value == 128: count = count + 1 node = node.next if count == 2: print("test insert success") else: print("test insert failed") except Exception: print("error test insert") print("------empty linked list------") s_list_empty = LinkedList() s_list_empty.print_all_nodes() nnew_empty = Node(10001) try: s_list_empty.insert(n2, nnew_empty) s_list_empty.print_all_nodes() print(s_list_empty.head, s_list_empty.head.value) print(s_list_empty.tail, s_list_empty.tail.value) if s_list_empty.head.value == 10001 and s_list_empty.tail.value == 10001 \ and s_list_empty.head == s_list_empty.tail: print("test insert in empty list success") else: print("test insert in empty list failed") except Exception: print("error test insert")