Add Optimized Shell Sort

DIRECTORY.md

@@ -444,7 +444,6 @@
   * [Scoring Functions](machine_learning/scoring_functions.py)
   * [Sequential Minimum Optimization](machine_learning/sequential_minimum_optimization.py)
   * [Similarity Search](machine_learning/similarity_search.py)
-  * [Support Vector Machines](machine_learning/support_vector_machines.py)
   * [Word Frequency Functions](machine_learning/word_frequency_functions.py)
 
 ## Maths
@@ -910,6 +909,7 @@
 
 ## Scheduling
   * [First Come First Served](scheduling/first_come_first_served.py)
+  * [Highest Response Ratio Next](scheduling/highest_response_ratio_next.py)
   * [Multi Level Feedback Queue](scheduling/multi_level_feedback_queue.py)
   * [Non Preemptive Shortest Job First](scheduling/non_preemptive_shortest_job_first.py)
   * [Round Robin](scheduling/round_robin.py)
@@ -973,6 +973,7 @@
   * [Recursive Quick Sort](sorts/recursive_quick_sort.py)
   * [Selection Sort](sorts/selection_sort.py)
   * [Shell Sort](sorts/shell_sort.py)
+  * [Shrink Shell](sorts/shrink_shell.py)
   * [Slowsort](sorts/slowsort.py)
   * [Stooge Sort](sorts/stooge_sort.py)
   * [Strand Sort](sorts/strand_sort.py)
@@ -1016,6 +1017,7 @@
   * [Reverse Words](strings/reverse_words.py)
   * [Split](strings/split.py)
   * [Upper](strings/upper.py)
+  * [Wave](strings/wave.py)
   * [Wildcard Pattern Matching](strings/wildcard_pattern_matching.py)
   * [Word Occurrence](strings/word_occurrence.py)
   * [Word Patterns](strings/word_patterns.py)

sorts/shrink_shell_sort.py

@@ -0,0 +1,66 @@
+"""
+This function implements the shell sort algorithm
+which is slightly faster than its pure implementation.
+
+This shell sort is implemented using a gap, which
+shrinks by a certain factor each iteration. In this
+implementation, the gap is initially set to the
+length of the collection. The gap is then reduced by
+a certain factor (1.3) each iteration.
+
+For each iteration, the algorithm compares elements
+that are a certain number of positions apart
+(determined by the gap). If the element at the higher
+position is greater than the element at the lower
+position, the two elements are swapped. The process
+is repeated until the gap is equal to 1.
+
+The reason this is more efficient is that it reduces
+the number of comparisons that need to be made. By
+using a smaller gap, the list is sorted more quickly.
+"""
+
+
+def shell_sort(collection: list) -> list:
+    """Implementation of shell sort algorithm in Python
+    :param collection:  Some mutable ordered collection with heterogeneous
+    comparable items inside
+    :return:  the same collection ordered by ascending
+
+    >>> shell_sort([3, 2, 1])
+    [1, 2, 3]
+    >>> shell_sort([])
+    []
+    >>> shell_sort([1])
+    [1]
+    """
+
+    # Choose an initial gap value
+    gap = len(collection)
+
+    # Set the gap value to be decreased by a factor of 1.3
+    # after each iteration
+    shrink = 1.3
+
+    # Continue sorting until the gap is 1
+    while gap > 1:
+
+        # Decrease the gap value
+        gap = int(gap / shrink)
+
+        # Sort the elements using insertion sort
+        for i in range(gap, len(collection)):
+            temp = collection[i]
+            j = i
+            while j >= gap and collection[j - gap] > temp:
+                collection[j] = collection[j - gap]
+                j -= gap
+            collection[j] = temp
+
+    return collection
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()