Merge pull request TheAlgorithms#30 from akshaysharma096/master

Traversal algorithms for Binary Tree.

Author: harshildarji

sorts/bogosort.py

@@ -11,6 +11,7 @@
 from __future__ importprint_function
 importrandom
 
+
 defbogosort(collection):
 """Pure implementation of the bogosort algorithm in Python
  :param collection: some mutable ordered collection with heterogeneous
@@ -28,13 +29,13 @@ def bogosort(collection):
 defisSorted(collection):
 iflen(collection) <2:
 returnTrue
-foriinrange(len(collection)-1):
-ifcollection[i] >collection[i+1]:
+foriinrange(len(collection)-1):
+ifcollection[i] >collection[i+1]:
 returnFalse
 returnTrue
 
 whilenotisSorted(collection):
-random.shuffle(collection)
+random.shuffle(collection)
 returncollection
 
 if__name__=='__main__':

sorts/bubble_sort.py

@@ -9,6 +9,7 @@
 For manual testing run:
 python bubble_sort.py
 """
+
 from __future__ importprint_function
 
 

sorts/heap_sort.py

@@ -12,6 +12,7 @@
 
 from __future__ importprint_function
 
+
 defheapify(unsorted, index, heap_size):
 largest=index
 left_index=2*index+1
@@ -26,6 +27,7 @@ def heapify(unsorted, index, heap_size):
 unsorted[largest], unsorted[index] =unsorted[index], unsorted[largest]
 heapify(unsorted, largest, heap_size)
 
+
 defheap_sort(unsorted):
 '''
  Pure implementation of the heap sort algorithm in Python
@@ -44,7 +46,7 @@ def heap_sort(unsorted):
  [-45, -5, -2]
  '''
 n=len(unsorted)
-foriinrange(n//2-1, -1, -1):
+foriinrange(n//2-1, -1, -1):
 heapify(unsorted, i, n)
 foriinrange(n-1, 0, -1):
 unsorted[0], unsorted[i] =unsorted[i], unsorted[0]

sorts/insertion_sort.py

@@ -30,8 +30,9 @@ def insertion_sort(collection):
  [-45, -5, -2]
  """
 forindexinrange(1, len(collection)):
-while0<indexandcollection[index] <collection[index-1]:
-collection[index], collection[index-1] =collection[index-1], collection[index]
+while0<indexandcollection[index] <collection[index-1]:
+collection[index], collection[
+index-1] =collection[index-1], collection[index]
 index-=1
 
 returncollection

sorts/selection_sort.py

@@ -17,7 +17,7 @@ def selection_sort(collection):
  :param collection: some mutable ordered collection with heterogeneous
  comparable items inside
  :return: the same collection ordered by ascending
-
+
 
  Examples:
  >>> selection_sort([0, 5, 3, 2, 2])
@@ -29,7 +29,7 @@ def selection_sort(collection):
  >>> selection_sort([-2, -5, -45])
  [-45, -5, -2]
  """
-
+
 length=len(collection)
 foriinrange(length):
 least=i

sorts/shell_sort.py

@@ -17,31 +17,30 @@ def shell_sort(collection):
  :param collection: Some mutable ordered collection with heterogeneous
  comparable items inside
  :return: the same collection ordered by ascending
-
+
  >>> shell_sort([0, 5, 3, 2, 2])
  [0, 2, 2, 3, 5]
 
  >>> shell_sort([])
  []
-
- >>> shell_sort([-2, -5, -45])
+
+ >>> shell_sort([-2, -5, -45])
  [-45, -5, -2]
  """
 # Marcin Ciura's gap sequence
 gaps= [701, 301, 132, 57, 23, 10, 4, 1]
-
+
 forgapingaps:
 i=gap
 whilei<len(collection):
 temp=collection[i]
 j=i
-whilej>=gapandcollection[j-gap] >temp:
+whilej>=gapandcollection[j-gap] >temp:
 collection[j] =collection[j-gap]
 j-=gap
 collection[j] =temp
 i+=1
-
-
+
 returncollection
 
 if__name__=='__main__':

traverals/binary_tree_traversals.py

@@ -0,0 +1,105 @@
+"""
+This is pure python implementation of tree traversal algorithms
+"""
+
+importqueue
+
+
+classTreeNode:
+
+def__init__(self, data):
+self.data=data
+self.right=None
+self.left=None
+
+
+defbuild_tree():
+print("Enter the value of the root node: ", end="")
+data=eval(input())
+ifdata<0:
+returnNone
+else:
+q=queue.Queue()
+tree_node=TreeNode(data)
+q.put(tree_node)
+whilenotq.empty():
+node_found=q.get()
+print("Enter the left node of %s: "%node_found.data, end="")
+left_data=eval(input())
+ifleft_data>=0:
+left_node=TreeNode(left_data)
+node_found.left=left_node
+q.put(left_node)
+print("Enter the right node of %s: "%node_found.data, end="")
+right_data=eval(input())
+ifright_data>=0:
+right_node=TreeNode(right_data)
+node_found.right=right_node
+q.put(right_node)
+returntree_node
+
+
+defpre_order(node):
+ifnotnode:
+return
+print(node.data, end=" ")
+pre_order(node.left)
+pre_order(node.right)
+
+
+defin_order(node):
+ifnotnode:
+return
+pre_order(node.left)
+print(node.data, end=" ")
+pre_order(node.right)
+
+
+defpost_order(node):
+ifnotnode:
+return
+post_order(node.left)
+post_order(node.right)
+print(node.data, end=" ")
+
+
+deflevel_order(node):
+ifnotnode:
+return
+q=queue.Queue()
+q.put(node)
+whilenotq.empty():
+node_dequeued=q.get()
+print(node_dequeued.data, end=" ")
+ifnode_dequeued.left:
+q.put(node_dequeued.left)
+ifnode_dequeued.right:
+q.put(node_dequeued.right)
+
+
+if__name__=='__main__':
+importsys
+print("\n********* Binary Tree Traversals ************\n")
+# For python 2.x and 3.x compatibility: 3.x has not raw_input builtin
+# otherwise 2.x's input builtin function is too "smart"
+ifsys.version_info.major<3:
+input_function=raw_input
+else:
+input_function=input
+
+node=build_tree()
+print("\n********* Pre Order Traversal ************")
+pre_order(node)
+print("\n******************************************\n")
+
+print("\n********* In Order Traversal ************")
+in_order(node)
+print("\n******************************************\n")
+
+print("\n********* Post Order Traversal ************")
+post_order(node)
+print("\n******************************************\n")
+
+print("\n********* Level Order Traversal ************")
+level_order(node)
+print("\n******************************************\n")