Merge pull request larymak#109 from karthiks2611/main

Added implementation of Data Structures and Algorithms

Author: larymak

Data Structures and Algorithms/Bubble_sort.py

@@ -0,0 +1,21 @@
+
+def BubbleSort(array):
+
+    # Loop to access each array element
+    for i in range(len(array)):
+        for j in range(0,len(array)-1-i):
+            # Replace > with < for descending order
+            if array[j] > array[j+1]:
+
+                # Swapping elements if elements are not in the intended order
+                temp = array[j] 
+                array[j] = array[j+1]
+                array[j+1] = temp
+    return array
+
+
+# Driver code
+if __name__ == '__main__':
+    Array = [-1,9,21,34,1,5,6,8,10,23,25,27,31]
+    print("Array before sorting: ", Array)
+    print("Array after sorting: ", BubbleSort(Array))

Data Structures and Algorithms/Heap_sort.py

@@ -0,0 +1,43 @@
+
+def Heapify(Array, n, i):
+    # Find largest among root and children
+    largest = i
+    l = 2 * i + 1
+    r = 2 * i + 2
+
+    if l < n and Array[l] > Array[largest]:
+        largest = l
+
+    if r < n and Array[r] > Array[largest]:
+        largest = r
+
+    # If root is not largest, swap with largest and continue heapifying
+    if largest != i:
+        Array[i], Array[largest] = Array[largest], Array[i]
+        Heapify(Array, n, largest)
+    
+
+def HeapSort(Array):
+    n = len(Array)
+
+    # Build a max heap
+    for i in range(n//2, -1, -1):
+        Heapify(Array, n, i)
+
+    # One by one extract elements
+    for i in range(n-1, 0, -1):
+        # Swap
+        Array[i], Array[0] = Array[0], Array[i]
+
+        # Heapify root element
+        Heapify(Array, i, 0)
+
+
+if __name__ == "__main__":
+    Array = [-2, -3, -1, 11, 9, 12, 4, -5, -12, 6, 19, 20]
+    HeapSort(Array)
+    n = len(Array)
+    print("Sorted array is")
+    for i in range(n):
+        print("%d " % Array[i], end='')
+  

Data Structures and Algorithms/Insertion_sort.py

@@ -0,0 +1,18 @@
+
+def insertionSort(Array):
+    for i in range(1, len(Array)):
+        key = Array[i]
+        j = i - 1
+
+        # Compare key with each element on the left of it until an element
+        #  smaller than it is found
+        # For descending order, change key<Array[j] to key>Array[j].
+        while j >= 0 and key < Array[j]:
+            Array[j + 1] = Array[j]
+            j -= 1
+        Array[j + 1] = key
+    return Array
+
+if __name__ == '__main__':
+    Array = [-2, -3, -1, 11, 9, 12, 4, -5, -12, 6, 19, 20]
+    print(insertionSort(Array))

Data Structures and Algorithms/README.md

@@ -18,6 +18,12 @@
 
 - Merge Sort
 
+- Bubble Sort
+
+- Heap Sort
+
+- Insertion Sort  
+
 - Quick Sort (for numbers)
 
 - Quick Sort (for strings)
@@ -26,4 +32,6 @@
 
 - Recursive Binary Search
 
-- Selection Sort
+- Selection Sort
+
+- Binary Tree traversal

Data Structures and Algorithms/Trees/binary_tree.py

@@ -0,0 +1,55 @@
+# Binary tree implementation along with tree traversals
+
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+    # Traverse pre-order
+    def traversePreOrder(self):
+        print(self.data, end=" ")
+        if self.left:
+            self.left.traversePreOrder()
+        if self.right:
+            self.right.traversePreOrder()
+
+    
+    # Traverse in-order
+    def traverseInOrder(self):
+        if self.left:
+            self.left.traverseInOrder()
+        print(self.data, end=" ")
+        if self.right:
+            self.right.traverseInOrder()
+
+    
+    # Traverse post-order
+    def traversePostOrder(self):
+        if self.left:
+            self.left.traversePostOrder()
+        if self.right:
+            self.right.traversePostOrder()
+        print(self.data, end=" ")
+
+
+root = Node(1)
+
+root.left = Node(2)
+root.right = Node(3)
+root.left.left = Node(4)
+root.left.right = Node(5)
+root.right.left = Node(6)
+root.right.right = Node(7)
+root.left.left.left = Node(8)
+root.left.left.right = Node(9)
+
+print("Pre Order traversal: ", end=" ")
+root.traversePreOrder()
+print()
+print("Post Order traversal: ",end=" ")
+root.traversePostOrder()
+print()
+print("In Order traversal: ",end=" ")
+root.traverseInOrder()
+print()