def test_linked_list_cycle_and_remove_with_cycle_count(): head_cycle = helper_generate_cycle_list() result, loop_ptr = helper_cycle_or_not(head_cycle) print "Calling linked_list_cycle_and_remove_with_cycle_count" linked_list_cycle_and_remove_with_cycle_count(head_cycle, loop_ptr) print_linked_list_contents(head_cycle) print "\n--------------"
def method_1_reverse_linked_list_after_k(head, k): temp_head = head length = count_no_of_elements(head) if k > length: print "Wrong input: k value greater than length" return if not head: print "list is empty" return count = 0 prev_head = None while temp_head and count < k: prev_head = temp_head temp_head = temp_head.next count += 1 print "\n head.contents:{0}".format(head) print "\n prev head contents:{0}".format(prev_head) print "\noriginal list: " print_linked_list_contents(head) reversed_k_head = reverse_linked_list(temp_head) print "\n reversed_k_head list:" print_linked_list_contents(reversed_k_head) prev_head.next = reverse_linked_list print "new::"
def testList(): node1 = Node("car") node2 = Node("bus") node3 = Node("lorry") node1.next = node2 node2.next = node3 print_linked_list_contents(node1)
def test_and_print(array): head1 = generate_linked_list_with_values(array) print "\n--------------" print "linked list before sorting" print_linked_list_contents(head1) head1 = sort_linked_list_efficiently(head1) print "\nlinked list after sorting" print_linked_list_contents(head1)
def test_and_print(array): head1 = generate_linked_list_with_values(array) print "\n--------------" print "linked list before even_and_odd" print_linked_list_contents(head1) head1 = linked_list_even_and_odd(head1) print "\nlinked list after even_and_odd" print_linked_list_contents(head1)
def format_output(lista, listb): print "---------------" print "lista : " print_linked_list_contents(lista) print "\nlistb : " print_linked_list_contents(listb) print "\ncomparing two lists : " print compare_two_string_linked_list(lista, listb) print "---------------"
def test_convert_array_to_linked_list(): print "# convert array to a linked list" head1 = convert_array_to_linked_list(['f', 'g', 'e', 'g', 'f']) print_linked_list_contents(head1) print "\n# reversed linked list" # does not work # reversed_head = head1 reversed_head = reverse_linked_list(convert_array_to_linked_list(['f', 'g', 'e', 'g', 'f'])) print_linked_list_contents(reversed_head)
def get_linked_list(length): head = Node() temp_node = head for i in xrange(1, length+1): node = Node(i) temp_node.next = node temp_node = temp_node.next head = head.next print_linked_list_contents(head) return head
def reverse_linked_list(head): currp = head prevp = None nextp = None while currp != None: nextp = currp.next currp.next = prevp prevp = currp currp = nextp print "prevp" print_linked_list_contents(prevp)
def reverse_linked_list_recursively(node): if node == None: return ; first_node = node rest_node = first_node.next print "reverse called with :", node if (rest_node == None): return ; #print rest_node reverse_linked_list_recursively(rest_node) print "returning back reverse called with : rest node :{0}, first_node:{1}".format(rest_node, first_node) first_node.next.next = first_node first_node.next = None node = rest_node print "printing node :", node, "rest_node :", rest_node print_linked_list_contents(node)
def test_and_print(array1, array2): head1 = generate_linked_list_with_values(array1) head2 = generate_linked_list_with_values(array2) print "\n--------------" print "linked list 1" print_linked_list_contents(head1) print "\nlinked list 2" #print "--------------" print_linked_list_contents(head2) head1= linked_list_merge_inplace(head1, head2) print "\nOutput of merging linked list 1 and 2:" print_linked_list_contents(head1)
while t_head != middle: if count%2: lista.append(t_head.contents) t_head = t_head.next else: lista.append(t_reversed_head.contents) t_reversed_head = t_reversed_head.next count = count + 1 lista.append(t_head.contents) new_head = generate_linked_list_with_values(lista) return new_head if __name__ == "__main__": head = generate_linked_list(6) print "actual order :" print_linked_list_contents(head) print "\nexpected output: 1->6->2->5->3->4" middle = middle_element_of_linked_list(head) rest_reversed = reverse_linked_list(middle) print "\nreversed :" print_linked_list_contents(rest_reversed) new_order = first_last_ordering_with_stack(head, rest_reversed, middle) print "\nnew linked list order :" print_linked_list_contents(new_order) print "\nnew linked list order without stack:" new_call = first_last_ordering_without_stack(head, rest_reversed, middle) print_linked_list_contents(new_call)
from _linked_list import Node from _helper_printers import print_linked_list_contents def insert_in_end(value, head): temp = head #if list is empty if head == None: return Node(value) while temp.next != None: temp = temp.next temp.next = Node(value) return head def delete_from_front(head): if head == None: return temp = head.next print "deleting :",head del head return temp node1 = insert_in_end(10, None) node2 = insert_in_end(20, node1) node3 = insert_in_end(30, node2) print_linked_list_contents(node3) node2 = delete_from_front(node3) node1 = delete_from_front(node2) node = delete_from_front(node1)
def test_linked_list_efficient_detect_and_remove(): head_cycle = helper_generate_cycle_list() print "Calling linked_list_efficient_detect_and_remove" linked_list_efficient_detect_and_remove(head_cycle) print_linked_list_contents(head_cycle) print "\n--------------"
""" http://www.geeksforgeeks.org/delete-middle-of-linked-list/ """ from middle_element_in_linked_list import middle_element_of_linked_list from _linked_list import get_linked_list from _helper_printers import print_linked_list_contents def delete_middle_element(head): if not head: return None slowp = fastp= head prev = None while fastp!= None and fastp.next!= None: fastp = fastp.next.next prev = slowp slowp = slowp.next prev.next = slowp.next del slowp return head if __name__ == '__main__': head = get_linked_list(5) print "middle element : " print "new linked list" new_head = delete_middle_element(head) print_linked_list_contents(new_head)
return number1, number2 def insert_in_front(head, diff): # insert extra nodes of zero in the front if head == None: return for i in range(diff): temp = Node(0) temp.next = head head = temp return head if __name__ == "__main__": # same size number1 = generate_linked_list_with_values([2, 4, 3]) number2 = generate_linked_list_with_values([5, 6, 4]) added_sum = add_two_numbers(number1, number2) print_linked_list_contents(added_sum) #different size diff_size_number1 = generate_linked_list_with_values([1, 2, 4, 3]) diff_size_number2 = generate_linked_list_with_values([6, 1, 4]) diff_size_added_sum = add_two_numbers(diff_size_number1, diff_size_number2) print_linked_list_contents(diff_size_added_sum) # test insert_in_front # number1 = generate_linked_list_with_values([2, 4, 3]) # head = insert_in_front(number1, 1)
def union(start1, start2): # union of two linked_list pass def intersection(start1, start2): # intersection of two linked_list pass def membership(): # Subsets and Powersets pass def cardinality(start): # For example, the set A = {2, 4, 6} contains 3 elements, # and therefore A has a cardinality of 3 pass # [10, 15, 4, 20] list1 = generate_linked_list_with_values([4, 10, 15, 20]) # [8, 4, 2, 10] list2 = generate_linked_list_with_values([2, 4, 8, 10]) print "list1: " print_linked_list_contents(list1) print "\nlist2: " print_linked_list_contents(list2)
next_ptr = curr_ptr.next #while curr_ptr and next_ptr: #while next_ptr.next: wrong #while next_ptr: while curr_ptr: #print " prev_ptr : {0}, curr_ptr: {1}, next_ptr: {2}".format(prev_ptr, curr_ptr, next_ptr) next_ptr = curr_ptr.next curr_ptr.next = prev_ptr prev_ptr = curr_ptr curr_ptr = next_ptr return prev_ptr def reverse_linked_list_recursively(head): print "yet to be implemented." pass if __name__ == "__main__": head = generate_linked_list(6) print "Orginal list" print_linked_list_contents(head) print "\nReversed list" print_linked_list_contents(reverse_linked_list(head)) empty_head = generate_linked_list(0) print_linked_list_contents(reverse_linked_list(empty_head)) #reverse_linked_list_recursively(head)
return None left = self.convert_to_BST_n(nu/2, head) node = Tree(head.contents) head = head.next node.left = left right = self.convert_to_BST_n(nu-nu/2-1, head) node.right = right return node if __name__ == '__main__': array = [5,6,7,8,9,10,20] ll_bst = linked_list_to_bst(array) #ll_bst.to_bst() # root = Tree(None) # root = ll_bst.convert_to_bst(0, 6) # root.print_node() # print root.left.data # now calling head = generate_linked_list_with_values(array) print_linked_list_contents(head) root = ll_bst.convert_to_BST_n(len(array)-1, head) tree_traveral = TreeTraversal() print "inorder : " tree_traveral.inorder(root) print "preorder : " tree_traveral.preorder(root) print "postorder : " tree_traveral.postorder(root)
def testEmptyList(): node1 = Node() print_linked_list_contents(node1)
return head def test_and_print(array): head1 = generate_linked_list_with_values(array) print "\n--------------" print "linked list before even_and_odd" print_linked_list_contents(head1) head1 = linked_list_even_and_odd(head1) print "\nlinked list after even_and_odd" print_linked_list_contents(head1) if __name__ == "__main__": arrays = [[1, 2, 3, 4], [10, 22, 30, 43, 56, 70], #odd size [10, 22, 30, 43, 56], # two elements [10,20], #one element [100] ] for array in arrays: test_and_print(array) #None type print "linked list before even_and_odd" print_linked_list_contents(None) head1 = linked_list_even_and_odd(None) print "\nlinked list after even_and_odd" print_linked_list_contents(head1)
def generate_linked_list_with_values(array): head = Node() temp_node = head for element in array: node = Node(element) temp_node.next = node temp_node = temp_node.next head = head.next return head def generate_double_linked_list(length, start=1): head = _double_linked_list_Node() temp_node = head prev_node = _double_linked_list_Node() for i in xrange(start, length+start): node = _double_linked_list_Node(i) temp_node.next = node prev_node = temp_node temp_node = temp_node.next temp_node.prev = prev_node head = head.next #print__double_linked_list_contents(head) return head if __name__ == "__main__": print_stack_contents(generate_empty_stack()) print_stack_contents(generate_stack(6)) print_linked_list_contents(generate_linked_list(4))
return result def decimal_equivalent(head): result = 0 while head != None: result = (result << 1) + head.contents head = head.next return result if __name__ == "__main__": array1 = [0, 0, 0, 1, 1, 0, 0, 1, 0] header1 = generate_linked_list_with_values(array1) print "print_linked_list_contents: " print_linked_list_contents(header1) print "count_no_of_elements : {0}".format(count_no_of_elements(header1)) print "decimal_equivalent_based_on_length : {0}".format( decimal_equivalent_based_on_length(header1, count_no_of_elements(header1)) ) print "decimal_equivalent : {0}".format(decimal_equivalent(header1)) array2 = [1, 0, 0] header2 = generate_linked_list_with_values(array2) print "print_linked_list_contents: " print_linked_list_contents(header2) print "count_no_of_elements : {0}".format(count_no_of_elements(header2)) print "decimal_equivalent_based_on_length : {0}".format( decimal_equivalent_based_on_length(header2, count_no_of_elements(header2)) ) print "decimal_equivalent : {0}".format(decimal_equivalent(header2))
# return # rest = first.next # if rest == None: # return # first.next.next = first # first.next = None # head = rest # return reverse_linked_list_recursively(rest) def reverse(node): def reverse_helper(old_head, new_head): if old_head is None: return new_head next_old_head = old_head.next old_head.next = new_head return reverse_helper(next_old_head, old_head) return reverse_helper(node, None) if __name__ == "__main__": print "hello" head = generate_linked_list(6) print "Orginal list" print_linked_list_contents(head) print "reversed linked list python" no_python_way = reverse(head) print_linked_list_contents(no_python_way) # print "reversed linked list" # no = reverse_linked_list_recursively(head) # print_linked_list_contents(no)