Initial commit.

Author: falloutcoder

Diff for: .gitignore

@@ -0,0 +1 @@
+*.pyc

Diff for: __init__.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+from __future__ import print_function
+import os
+import sys
+import glob
+import random
+import argparse
+import importlib
+
+from tabulate import tabulate
+
+
+def sort_algos(sample, sample_size, no_of_times, sample_range):
+    pretty_print = lambda char, count: (print("{}".format(char*count)))
+    current_dir = os.path.dirname(os.path.realpath(__file__))
+
+    sorting_algos = glob.glob("{}/*_sort.py".format(current_dir))
+    sorting_algos = [x.split('/')[-1][:-3] for x in sorting_algos]
+
+    time_taken = [['Algorithm Name', 'Time Taken (Less Is Better!!)'], ]
+    for algo in sorting_algos:
+        module = importlib.import_module(algo)
+        time_taken.append([algo.title().replace('_', ' '),
+                           "{0:.20f} sec".format(getattr(module, algo)(array=sample[:],
+                                                                       repeat=no_of_times).time)])
+    pretty_print('|', 50)
+    print(
+        "Sorting Algorithms Ran!\nArray Details And Algorithms Summary As Follow")
+    pretty_print('|', 50)
+    pretty_print('-', 50)
+    print("Length Of Array: {}".format(sample_size))
+    print("Range Of Numbers In Array: 0 to {}".format(sample_range-1))
+    print("Number Of Times Array Were Sorted: {}".format(no_of_times))
+    pretty_print('-', 50)
+    print(tabulate(sorted(time_taken, key=lambda x: x[1], reverse=True),
+                   headers='firstrow', tablefmt="fancy_grid"))
+
+
+def run():
+    """
+    Main Function to execute sorting algorithms
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-s", "--size",
+                        type=int,
+                        help="Size of array to be sorted",
+                        default=1000)
+    parser.add_argument("-l", "--loop",
+                        type=int,
+                        help="Number of times array sorting should be repeated",
+                        default=1)
+    parser.add_argument("-r", "--range",
+                        type=int,
+                        help="Max range of number that should be present in array",
+                        default=None)
+    args = parser.parse_args()
+
+    size = args.size
+    repeat = args.loop
+    max_range = args.range if args.range else size
+
+    # Generate sample which will be sorted by all algorithms
+    sample = []
+    try:
+        sample = random.sample(range(max_range), size)
+    except ValueError:
+        print("Provided values range has to be greater than sample size")
+        return None
+    # Run all sorting algorithms
+    sort_algos(sample, size, no_of_times=repeat, sample_range=max_range)
+
+if __name__ == "__main__":
+    run()

Diff for: __main__.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+# coding: utf-8
+"""
+|------------------------------------------------------------|
+|                       Bubble Sort                          |
+|------------------------------------------------------------|
+|Also known as               ||  sinking sort                |
+|Worst case performance      ||  О(n2)                       |
+|Best case performance       ||  O(n)                        |
+|Average case performance    ||  О(n2)                       |
+|Worst case space complexity ||  O(1) auxiliary              |
+|------------------------------------------------------------|
+"""
+
+from decorators import timethis
+
+
+@timethis
+def bubble_sort(array):
+    size = len(array)
+    for i in range(size):
+        for j in range(i+1, size):
+            if array[j] < array[i]:
+                array[j], array[i] = array[i], array[j]
+    return array

Diff for: bubble_sort.py

@@ -0,0 +1,29 @@
+import timeit
+from collections import namedtuple
+
+def _template_func(setup, func):
+    """
+    Monkey Patching original timer function's _template_func.
+    This is used if the "statement" is a callable. and returns a
+    namedtuple containing 'output' property which has callable's
+    result and 'time' property which has time taken by the  to complete
+    """
+
+    Result = namedtuple('Result', ['time', 'output'])
+    def inner(_it, _timer, _func=func):
+        setup()
+        _t0 = _timer()
+        for _i in _it:
+            output = _func()
+        _t1 = _timer()
+        timetaken = _t1 - _t0
+        return Result(timetaken, output)
+    return inner
+
+timeit._template_func = _template_func
+
+def timethis(fun):
+    def _wrapped(*args, **kwargs):
+        t = timeit.Timer(lambda: fun(*args, **kwargs))
+        return t.timeit(number=kwargs.pop('repeat', 1))
+    return _wrapped

Diff for: decorators.py

@@ -0,0 +1,29 @@
+# coding: utf-8
+"""
+|------------------------------------------------------------|
+|                     Insertion Sort                         |
+|------------------------------------------------------------|
+|Type                        ||  In-place stable sort        |
+|Worst case performance      ||  O(n2) comparisons, swaps    |
+|Best case performance       ||  Ω(n) comparisons, O(1) swaps|
+|Average case performance    ||  O(n2) comparisons, swaps    |
+|Worst case space complexity ||  O(n) total, O(1) auxiliary  |
+|------------------------------------------------------------|
+"""
+
+from decorators import timethis
+
+
+@timethis
+def insertion_sort(array):
+    size = len(array)
+    for index in range(1, size):
+        val = array[index]
+        position = index
+
+        while position > 0 and array[position-1] > val:
+            array[position] = array[position-1]
+            position = position-1
+
+        array[position] = val
+    return array

Diff for: insertion_sort.py

@@ -0,0 +1,48 @@
+"""
+|-----------------------------------------------------------|
+|                       Merge Sort                          |
+|-----------------------------------------------------------|
+|Type                        ||  Comparison base stable sort|
+|Worst case performance      ||  O(n log n)                 |
+|Best case performance       ||  O(n log n) or O(n)         |
+|Average case performance    ||  O(n log n)                 |
+|Worst case space complexity ||  O(n) or O(log n)           |
+|-----------------------------------------------------------|
+"""
+
+from decorators import timethis
+
+
+@timethis
+def merge_sort(array):
+    def _sort(array):
+        # Actual Merge Sort Function
+        if len(array) == 1:
+            return array
+        else:
+            mid = len(array)/2
+            left = _sort(array[:mid])
+            right = _sort(array[mid:])
+
+            left_counter, right_counter, counter = 0, 0, 0
+
+            while left_counter < len(left) and right_counter < len(right):
+                if left[left_counter] < right[right_counter]:
+                    array[counter] = left[left_counter]
+                    left_counter += 1
+                    counter += 1
+                else:
+                    array[counter] = right[right_counter]
+                    right_counter += 1
+                    counter += 1
+
+            remaining = left if left_counter < right_counter else right
+            r = left_counter if remaining == left else right_counter
+
+            while r < len(remaining):
+                array[counter] = remaining[r]
+                r += 1
+                counter += 1
+            return array
+    # Call the Merge Sort Function
+    return _sort(array)

Diff for: merge_sort.py

@@ -0,0 +1,36 @@
+"""
+|-----------------------------------------------------------|
+|                       Quick Sort                          |
+|-----------------------------------------------------------|
+|Type                        ||  Comparison sort            |
+|Worst case performance      ||  O(n2)                      |
+|Best case performance       ||  O(n log n) or O(n)         |
+|Average case performance    ||  O(n log n)                 |
+|Worst case space complexity ||  O(n) or O(log n)           |
+|-----------------------------------------------------------|
+"""
+
+from decorators import timethis
+
+
+@timethis
+def quick_sort(array):
+    def _sort(array):
+        # Actual Quick Sort Function
+        less = []
+        equal = []
+        greater = []
+        if len(array) > 1:
+            pivot = array[0]
+            for x in array:
+                if x < pivot:
+                    less.append(x)
+                elif x == pivot:
+                    equal.append(x)
+                else:
+                    greater.append(x)
+            return _sort(less)+equal+_sort(greater)
+        else:
+            return array
+    # Call the Quick Sort Function
+    return _sort(array[:])

Diff for: quick_sort.py

@@ -0,0 +1 @@
+tabulate

Diff for: requirements.txt

@@ -0,0 +1,25 @@
+"""
+|-----------------------------------------------------------|
+|                     Selection Sort                        |
+|-----------------------------------------------------------|
+|Type                        ||  In-place comparison sort   |
+|Worst case performance      ||  O(n2)                      |
+|Best case performance       ||  O(n2)                      |
+|Average case performance    ||  O(n2)                      |
+|Worst case space complexity ||  O(n) total, O(1) auxiliary |
+|-----------------------------------------------------------|
+"""
+
+from decorators import timethis
+
+
+@timethis
+def selection_sort(array):
+    size = len(array)
+    for i in range(size):
+        smallest = i
+        for x in range(i+1, size):
+            if array[smallest] > array[x]:
+                smallest = x
+        array[i], array[smallest] = array[smallest], array[i]
+    return array

Diff for: selection_sort.py

@@ -0,0 +1,28 @@
+"""
+|-----------------------------------------------------------|
+|                        Shell Sort                         |
+|-----------------------------------------------------------|
+|Type                        ||  In-place comparison sort   |
+|Worst case performance      ||  O(n2)                      |
+|Best case performance       ||  O(n log2 n)                |
+|Average case performance    ||  depends on gap sequence    |
+|Worst case space complexity ||  O(n) total, O(1) auxiliary |
+|-----------------------------------------------------------|
+"""
+
+from decorators import timethis
+
+
+@timethis
+def shell_sort(array):
+    mid = len(array) / 2
+    while mid:
+        for i in range(len(array)):
+            j = i
+            temp = array[i]
+            while j >= mid and array[j-mid] > temp:
+                array[j] = array[j - mid]
+                j -= mid
+            array[j] = temp
+        mid = mid/2 if mid/2 else (0 if mid == 1 else 1)
+    return array

Diff for: shell_sort.py

@@ -0,0 +1,32 @@
+import os
+import glob
+import random
+import importlib
+import unittest
+
+class SortAlgosTest(unittest.TestCase):
+    def setUp(self):
+        """
+        Common setup to load all sorting modules in current package
+        following name convention of endswith('_sort.py'). Imprt 
+        """
+        current_dir = os.path.dirname(os.path.realpath(__file__))
+        sorting_algos = glob.glob("{}/*_sort.py".format(current_dir))
+        sorting_algos = [x.split('/')[-1][:-3] for x in sorting_algos]
+        modules = [importlib.import_module(algo) for algo in sorting_algos]
+
+        self.sorting_algos = zip(sorting_algos, modules)
+
+    def test_algos_with_sequential_array(self):
+        """
+        Test a shuffeld sample of 50 numbers. Sorted array contains
+        50 numbers in sequence. Strating from 0 to 49
+        """
+        self.array = random.sample(range(50), 50)
+        for algo, module in self.sorting_algos:
+            print ("Testing {}".format(algo))
+            result = getattr(module, algo)(array=self.array[:], repeat=1).output
+            for index, val in enumerate(range(50)):
+                assert val == result[index]
+if __name__ == '__main__':
+    unittest.main()

Diff for: test.py

@@ -0,0 +1,18 @@
+"""
+|-----------------------------------------------------------|
+|                         Tim Sort                          |
+|-----------------------------------------------------------|
+|Created By Tim Roberts      ||  Python's Builtin Sort      |
+|Worst case performance      ||  O(n log n)                 |
+|Best case performance       ||  O(n)                       |
+|Average case performance    ||  O(n log n)                 |
+|Worst case space complexity ||  O(n)                       |
+|-----------------------------------------------------------|
+"""
+
+from decorators import timethis
+
+
+@timethis
+def tim_sort(array):
+    return sorted(array)