@@ -0,0 +1,17 @@
+def brick_sort(arr, n): 
+    # Initially array is unsorted 
+    isSorted = 0
+    while isSorted == 0: 
+        isSorted = 1
+        temp = 0
+        for i in range(1, n-1, 2): 
+            if arr[i] > arr[i+1]: 
+                arr[i], arr[i+1] = arr[i+1], arr[i] 
+                isSorted = 0
+                  
+        for i in range(0, n-1, 2): 
+            if arr[i] > arr[i+1]: 
+                arr[i], arr[i+1] = arr[i+1], arr[i] 
+                isSorted = 0
+      
+    return
@@ -0,0 +1,57 @@
+'''
+Created by: Pratik Narola (https://github.com/Pratiknarola)
+last modified: 14-10-2019
+'''
+
+'''
+
+Cocktail Sort is a variation of Bubble sort. 
+The Bubble sort algorithm always traverses elements from left
+and moves the largest element to its correct position in first iteration 
+and second largest in second iteration and so on. 
+Cocktail Sort traverses through a given array in both directions alternatively.
+
+'''
+
+def cocktail_sort(a): 
+    n = len(a) 
+    swapped = True
+    start = 0
+    end = n-1
+    while swapped: 
+  
+        # reset the swapped flag on entering the loop, 
+        # because it might be true from a previous 
+        # iteration. 
+        swapped = False
+  
+        # loop from left to right same as the bubble 
+        # sort 
+        for i in range(start, end): 
+            if a[i] > a[i + 1]: 
+                a[i], a[i + 1] = a[i + 1], a[i] 
+                swapped = True
+  
+        # if nothing moved, then array is sorted. 
+        if not swapped: 
+            break
+  
+        # otherwise, reset the swapped flag so that it 
+        # can be used in the next stage 
+        swapped = False
+  
+        # move the end point back by one, because 
+        # item at the end is in its rightful spot 
+        end -= 1
+  
+        # from right to left, doing the same 
+        # comparison as in the previous stage 
+        for i in range(end-1, start-1, -1): 
+            if a[i] > a[i + 1]: 
+                a[i], a[i + 1] = a[i + 1], a[i] 
+                swapped = True
+  
+        # increase the starting point, because 
+        # the last stage would have moved the next 
+        # smallest number to its rightful spot. 
+        start = start + 1
@@ -0,0 +1,32 @@
+'''
+Created by: Pratik Narola (https://github.com/Pratiknarola)
+last modified: 14-10-2019
+'''
+
+'''
+
+Gnome Sort also called Stupid sort is based on the concept of a Garden Gnome sorting his flower pots.
+A garden gnome sorts the flower pots by the following method-
+
+He looks at the flower pot next to him and the previous one; 
+if they are in the right order he steps one pot forward, otherwise he swaps them and steps one pot backwards.
+If there is no previous pot (he is at the starting of the pot line), he steps forwards; 
+if there is no pot next to him (he is at the end of the pot line), he is done.
+
+'''
+
+
+
+# A function to sort the given list using Gnome sort 
+def gnome_sort( arr, n): 
+    index = 0
+    while index < n: 
+        if index == 0: 
+            index = index + 1
+        if arr[index] >= arr[index - 1]: 
+            index = index + 1
+        else: 
+            arr[index], arr[index-1] = arr[index-1], arr[index] 
+            index = index - 1
+  
+    return arr
@@ -0,0 +1,69 @@
+from insertion_sort import sort
+# iterative Timsort function to sort the  
+# array[0...n-1] (similar to merge sort)  
+def tim_sort(arr, n):  
+   
+    # Sort individual subarrays of size RUN  
+    for i in range(0, n, RUN):  
+        sort(arr, i, min((i+31), (n-1)))  
+    
+    # start merging from size RUN (or 32). It will merge  
+    # to form size 64, then 128, 256 and so on ....  
+    size = RUN 
+    while size < n:  
+       
+        # pick starting point of left sub array. We  
+        # are going to merge arr[left..left+size-1]  
+        # and arr[left+size, left+2*size-1]  
+        # After every merge, we increase left by 2*size  
+        for left in range(0, n, 2*size):  
+           
+            # find ending point of left sub array  
+            # mid+1 is starting point of right sub array  
+            mid = left + size - 1 
+            right = min((left + 2*size - 1), (n-1))  
+    
+            # merge sub array arr[left.....mid] &  
+            # arr[mid+1....right]  
+            merge(arr, left, mid, right)  
+          
+        size = 2*size 
+
+def merge(arr, l, m, r): 
+   
+    # original array is broken in two parts  
+    # left and right array  
+    len1, len2 =  m - l + 1, r - m  
+    left, right = [], []  
+    for i in range(0, len1):  
+        left.append(arr[l + i])  
+    for i in range(0, len2):  
+        right.append(arr[m + 1 + i])  
+    
+    i, j, k = 0, 0, l 
+    # after comparing, we merge those two array  
+    # in larger sub array  
+    while i < len1 and j < len2:  
+       
+        if left[i] <= right[j]:  
+            arr[k] = left[i]  
+            i += 1 
+           
+        else: 
+            arr[k] = right[j]  
+            j += 1 
+           
+        k += 1
+       
+    # copy remaining elements of left, if any  
+    while i < len1:  
+       
+        arr[k] = left[i]  
+        k += 1 
+        i += 1
+    
+    # copy remaining element of right, if any  
+    while j < len2:  
+        arr[k] = right[j]  
+        k += 1
+        j += 1