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)
