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)
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 first_last_ordering_with_stack(head, reversed_head, middle):
if not _check_parameters(head, reversed_head, middle):
return
t_head = head
t_reversed_head = reversed_head
count = 1
lista = []
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
def test_case_four(): lista = generate_linked_list_with_values(['e', 'e', 'e', 'k', 's', 'a']) listb = generate_linked_list_with_values(['g', 'e', 'e', 'k', 's']) return lista, listb
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)
len2 = count_no_of_elements(node2)
print "len1 :", len1
print "len2 :", len2
# move the pointers
diff = abs(len1 - len2)
if (len1>len2):
i = 0
while (i<diff):
node1 = node1.next
i += 1
else:
i = 0
while (i<diff):
node2 = node2.next
i += 1
while (node1 != None and node2 != None):
print "node1: {0}, node2:{1}".format(node1.contents, node2.contents)
if node1.contents == node2.contents:
return node1
node1 = node1.next
node2 = node2.next
return None
if __name__ == "__main__":
node1 = generate_linked_list_with_values([1, 2, 4, 3])
node2 = generate_linked_list_with_values([10, 6, 1, 4, 3])
print intersection_of_two_linked_list(node1, node2)
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)
result = result + head.contents * (pow(2, i))
head = head.next
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))
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)
