@@ -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://.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://.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