AllAlgorithms · abranhe · Oct 4, 2018 · Oct 2, 2018 · Oct 2, 2018
diff --git a/searches/ternary_search.py b/searches/ternary_search.py
@@ -0,0 +1,107 @@
+'''
+This is a type of divide and conquer algorithm which divides the search space into
+3 parts and finds the target value based on the property of the array or list 
+(usually monotonic property).
+
+Time Complexity  : O(log3 N)
+Space Complexity : O(1)
+'''
+from __future__ import print_function
+
+import sys
+
+try:
+    raw_input          # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+# This is the precision for this function which can be altered.
+# It is recommended for users to keep this number greater than or equal to 10.
+precision = 10
+
+# This is the linear search that will occur after the search space has become smaller.
+def lin_search(left, right, A, target):
+    for i in range(left, right+1):
+        if(A[i] == target):
+            return i
+
+# This is the iterative method of the ternary search algorithm.
+def ite_ternary_search(A, target):
+    left = 0
+    right = len(A) - 1;
+    while(True):
+        if(left<right):
+
+            if(right-left < precision):
+                return lin_search(left,right,A,target)
+
+            oneThird = (left+right)/3+1;
+            twoThird = 2*(left+right)/3+1;
+
+            if(A[oneThird] == target):
+                return oneThird
+            elif(A[twoThird] == target):
+                return twoThird
+
+            elif(target < A[oneThird]):
+                right = oneThird-1
+            elif(A[twoThird] < target):
+                left = twoThird+1
+
+            else:
+                left = oneThird+1
+                right = twoThird-1
+        else:
+            return None
+
+# This is the recursive method of the ternary search algorithm.
+def rec_ternary_search(left, right, A, target):
+    if(left<right):
+
+        if(right-left < precision):
+            return lin_search(left,right,A,target)
+
+        oneThird = (left+right)/3+1;
+        twoThird = 2*(left+right)/3+1;
+
+        if(A[oneThird] == target):
+            return oneThird
+        elif(A[twoThird] == target):
+            return twoThird
+
+        elif(target < A[oneThird]):
+            return rec_ternary_search(left, oneThird-1, A, target)
+        elif(A[twoThird] < target):
+            return rec_ternary_search(twoThird+1, right, A, target)
+
+        else:
+            return rec_ternary_search(oneThird+1, twoThird-1, A, target)
+    else:
+        return None
+
+# This function is to check if the array is sorted.
+def __assert_sorted(collection):
+    if collection != sorted(collection):
+        raise ValueError('Collection must be sorted')
+    return True
+
+
+if __name__ == '__main__':
+    user_input = raw_input('Enter numbers separated by coma:\n').strip()
+    collection = [int(item) for item in user_input.split(',')]
+
+    try:
+        __assert_sorted(collection)
+    except ValueError:
+        sys.exit('Sequence must be sorted to apply the ternary search')
+
+    target_input = raw_input('Enter a single number to be found in the list:\n')
+    target = int(target_input)
+    result1 = ite_ternary_search(collection, target)
+    result2 = rec_ternary_search(0, len(collection)-1, collection, target)
+
+    if result2 is not None:
+        print('Iterative search: {} found at positions: {}'.format(target, result1))
+        print('Recursive search: {} found at positions: {}'.format(target, result2))
+    else:
+        print('Not found')
diff --git a/sorting/heap_sort.py b/sorting/heap_sort.py
@@ -0,0 +1,65 @@
+#!usr/bin/python3
+'''
+This is a pure python implementation of the heap sort algorithm.
+
+For doctests run following command:
+python -m doctest -v heap_sort.py
+or
+python3 -m doctest -v heap_sort.py
+
+For manual testing run:
+python heap_sort.py
+'''
+
+from __future__ import print_function
+
+
+def heapify(unsorted, index, heap_size):
+    largest = index
+    left_index = 2 * index + 1
+    right_index = 2 * index + 2
+    if left_index < heap_size and unsorted[left_index] > unsorted[largest]:
+        largest = left_index
+
+    if right_index < heap_size and unsorted[right_index] > unsorted[largest]:
+        largest = right_index
+
+    if largest != index:
+        unsorted[largest], unsorted[index] = unsorted[index], unsorted[largest]
+        heapify(unsorted, largest, heap_size)
+
+
+def heap_sort(unsorted):
+    '''
+    Pure implementation of the heap sort algorithm in Python
+    :param collection: some mutable ordered collection with heterogeneous
+    comparable items inside
+    :return: the same collection ordered by ascending
+
+    Examples:
+    >>> heap_sort([0, 5, 3, 2, 2])
+    [0, 2, 2, 3, 5]
+
+    >>> heap_sort([])
+    []
+
+    >>> heap_sort([-2, -5, -45])
+    [-45, -5, -2]
+    '''
+    n = len(unsorted)
+    for i in range(n // 2 - 1, -1, -1):
+        heapify(unsorted, i, n)
+    for i in range(n - 1, 0, -1):
+        unsorted[0], unsorted[i] = unsorted[i], unsorted[0]
+        heapify(unsorted, 0, i)
+    return unsorted
+
+if __name__ == '__main__':
+    try:
+        raw_input          # Python 2
+    except NameError:
+        raw_input = input  # Python 3
+
+    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    unsorted = [int(item) for item in user_input.split(',')]
+    print(heap_sort(unsorted))