sorting-suite 1.0.1__py3-none-any.whl

sorting_suite/__init__.py

@@ -0,0 +1,33 @@
+from .sorting import (
+    swap,
+    is_sorted,
+    reverse,
+    selection_sort,
+    shell_sort,
+    heap_sort,
+    bitonic_sort,
+    insertion_sort,
+    bogo_sort,
+    merge_sort,
+    quick_sort,
+    bubble_sort,
+    bucket_sort,
+    comb_sort,
+)
+
+__all__ = [
+    "swap",
+    "is_sorted",
+    "reverse",
+    "selection_sort",
+    "shell_sort",
+    "heap_sort",
+    "bitonic_sort",
+    "insertion_sort",
+    "bogo_sort",
+    "merge_sort",
+    "quick_sort",
+    "bubble_sort",
+    "bucket_sort",
+    "comb_sort"
+]

sorting_suite/sorting.py

@@ -0,0 +1,209 @@
+# Swaps arr[i] and arr[j]
+# Runtime: O(1)
+def swap(arr, i, j):
+    temp = arr[i]
+    arr[i] = arr[j]
+    arr[j] = temp
+
+# Checks if a list is sorted
+# Runtime: O(n)
+def is_sorted(arr):
+    if not arr:
+        return True
+    return all(arr[i] <= arr[i + 1] for i in range(len(arr) - 1))
+
+# Reverses a list
+# Call on a sorted list to reverse the sorting order
+# Runtime: O(n)
+def reverse(arr):
+    return arr[::-1]
+
+# Sorts by "bubbling" large elements up into the correct spots
+# Stable
+# Runtime: O(n^2)
+def bubble_sort(arr):
+    arr = arr.copy()
+    n = len(arr)
+    for i in range(n):
+        for j in range(0, n - i - 1):
+            if arr[j] > arr[j + 1]:
+                arr[j], arr[j + 1] = arr[j + 1], arr[j]
+    return arr    
+
+# Sorts by picking pivots, partioning the list into sections, and recursively sorting the parts
+# Runtime: O(n^2)
+def quick_sort(arr):
+    if len(arr) <= 1:
+        return arr
+    pivot = arr[len(arr) // 2]
+    left = [x for x in arr if x < pivot]
+    mid  = [x for x in arr if x == pivot]
+    right = [x for x in arr if x > pivot]
+    return quick_sort(left) + mid + quick_sort(right)
+
+# Sorts by inserting elements into the correct order one at a time
+# Stable
+# Runtime: O(n^2)
+def insertion_sort(arr):
+    arr = arr.copy()
+    for i in range(1,len(arr)):
+        k = arr[i]
+        j = i - 1
+
+        while j >= 0 and arr[j] > k:
+            arr[j + 1] = arr[j]
+            j -= 1
+
+        arr[j + 1] = k
+    return arr
+
+# Sorts by finding the next smallest elements and placing at front
+# Runtime: O(n^2)
+def selection_sort(arr):
+    arr = arr.copy()
+    n = len(arr)
+    for i in range(n):
+        min_inx = i
+        for j in range(i+1, n):
+            if arr[j] < arr[min_inx]:
+                min_inx = j
+        arr[i], arr[min_inx] = arr[min_inx], arr[i]
+    return arr
+
+# Sorts by spliting the list in half and recursively sorting
+# Stable
+# Runtime: O(nlog(n))
+def merge_sort(arr):
+    if len(arr) <= 1:
+        return arr
+    
+    mid = len(arr) // 2
+    left = merge_sort(arr[:mid])
+    right = merge_sort(arr[mid:])
+    
+    return _merge(left, right)
+
+def _merge(left, right):
+    i = j = 0
+    result = []
+    
+    while i < len(left) and j < len(right):
+        if left[i] <= right[j]: 
+            result.append(left[i])
+            i += 1
+        else:
+            result.append(right[j])
+            j += 1
+    
+    return result + left[i:] + right[j:]
+
+# Sorts by randomizing the list order and checking if the list is sorted
+# Runtime: O(inf)
+def bogo_sort(arr):
+    import random
+    arr = arr.copy()
+    while not is_sorted(arr):
+        random.shuffle(arr)
+    return arr
+
+# Sorts by sorting into buckets, sorting the buckets, and concatenating
+# Stable
+# Runtime: O(n+k), where k is number of buckets
+def bucket_sort(arr, bucket_size=10):
+    if len(arr) == 0:
+        return arr
+    arr = arr.copy()
+    min_val, max_val = min(arr), max(arr)
+    bucket_count = (max_val - min_val) // bucket_size + 1
+    buckets = [[] for _ in range(bucket_count)]
+
+    for num in arr:
+        index = (num - min_val) // bucket_size
+        buckets[index].append(num)
+
+    sorted_arr = []
+    for bucket in buckets:
+        sorted_arr.extend(insertion_sort(bucket)) 
+
+    return sorted_arr
+
+# Sorts by comparing far apart elements and moving them
+# Runtime: O(n^2)
+def shell_sort(arr):
+    arr = arr.copy()
+    n = len(arr)
+    gap = n // 2
+    while gap > 0:
+        for i in range(gap, n):
+            temp = arr[i]
+            j = i
+            while j >= gap and arr[j - gap] > temp:
+                arr[j] = arr[j - gap]
+                j -= gap
+            arr[j] = temp
+        gap //= 2
+    return arr
+
+# Sorts by taking advantage of binary sequences
+# Runtime: O(log^2(n))
+def bitonic_sort(arr):
+    n = len(arr)
+    for k in range(2, n+1):
+        j = k // 2
+        while j > 0:
+            for i in range(0, n):
+                l = i ^ j
+                if l > i:
+                    if ( ((i&k)==0) and (arr[i] > arr[l]) or ( ( (i&k)!=0) and (arr[i] < arr[l])) ):
+                        temp = arr[i]
+                        arr[i] = arr[l]
+                        arr[l] = temp
+            j //= 2
+
+# Sorts by using a binary min heap
+# Runtime: O(log(n))
+def heap_sort(arr):
+    n = len(arr)
+
+    for i in range(n//2, -1, -1):
+      __heapify(arr, n, i)
+    
+    for i in range(n-1, 0, -1):
+      arr[i], arr[0] = arr[0], arr[i]
+
+      __heapify(arr, i, 0)
+
+def __heapify(arr, n, i):
+    largest = i
+    l = 2 * i + 1
+    r = 2 * i + 2
+
+    if l < n and arr[i] < arr[l]:
+        largest = l
+
+    if r < n and arr[largest] < arr[r]:
+        largest = r
+
+    if largest != i:
+        arr[i], arr[largest] = arr[largest], arr[i]
+        __heapify(arr, n, largest)
+
+# Sorts similarly to bubble sort, but removes turtles
+# Runtime: O(n^2)
+def comb_sort(arr):
+    n = len(arr)
+    s = 1.3
+    gap = n
+    sorted = False
+
+    while not sorted:
+        gap = int(gap/s)
+        if gap <= 1:
+            sorted = True
+            gap = 1
+
+        for i in range(n-gap):
+            sm = gap + i
+            if arr[i] > arr[sm]:
+                arr[i], arr[sm] = arr[sm], arr[i]
+                sorted = False

sorting_suite/testing.py

@@ -0,0 +1,67 @@
+from sorting import (
+    swap,
+    is_sorted,
+    reverse,
+    selection_sort,
+    shell_sort,
+    heap_sort,
+    insertion_sort,
+    bogo_sort,
+    merge_sort,
+    quick_sort,
+    bubble_sort,
+    bucket_sort,
+    comb_sort
+)
+
+def test_sorting_functions():
+    test_cases = [
+        [],
+        [1],
+        [2, 1],
+        [4, 2, 7, 1, 3],
+        [5, 3, 8, 5, 2, 2, 9],
+        [1, 2, 3, 4, 5],   
+        [5, 4, 3, 2, 1], 
+        [435, 2, 1090, 123, 345, 24, 45, -1204],
+        [-90, -1, 0, 32, -4],
+        [-1],
+        [1, 1, 2, 0, 1, 1, 1, 2, 0, 1]  
+    ]
+
+    sorting_functions = [
+        selection_sort,
+        insertion_sort,
+        shell_sort,
+        heap_sort,
+        merge_sort,
+        quick_sort,
+        bubble_sort,
+        bucket_sort,
+        bogo_sort,
+        comb_sort
+    ]
+
+    for func in sorting_functions:
+        print(f"\nTesting {func.__name__}:")
+        for arr in test_cases:
+            if func == bogo_sort and len(arr) > 3:
+                continue
+            result = func(arr)
+            print(f"Input: {arr} -> Output: {result} -> Sorted: {is_sorted(result)}")
+
+def test_utilities():
+    print("\nTesting utility functions:")
+    
+    arr = [4,5,6]
+    swap(arr, 0, 2)
+    print(f"swap([4,5,6],0,2) -> ({arr})")
+
+    arr = [1,2,3]
+    print(f"reverse([1,2,3]) -> {reverse(arr)}")
+    print(f"is_sorted([1,2,3]) -> {is_sorted([1,2,3])}")
+    print(f"is_sorted([3,1,2]) -> {is_sorted([3,1,2])}")
+
+if __name__ == "__main__":
+    test_sorting_functions()
+    test_utilities()

sorting_suite-1.0.1.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: sorting-suite
+Version: 1.0.1
+Summary: A large suite of numerical sorting algorithms in Python
+Home-page: https://reesefairchild.github.io/sorting-suite
+Author: Reese Fairchild
+Author-email: rfair@uw.edu
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+**sorting-suite** is a simple Python library providing a comprehensive collection of numerical sorting algorithms, along with helpful utility functions.  
+---
+
+## Sorting Algorithms by Average Runtime
+
+**O(n + k)**
+- Bucket Sort
+
+**O(log^2 n)**
+- Bitonic Sort (can only be used on lists with size that is multiple of 2)
+
+**O(n log n)**
+- Heap Sort
+- Merge Sort
+- Quick Sort
+- Shell Sort
+
+**O(n^2)**
+- Bubble Sort
+- Comb Sort
+- Insertion Sort
+- Selection Sort
+
+**O(n!)**
+- Bogo Sort (please do not use this one)
+
+---
+
+## Stable Sorts
+- Bucket Sort
+- Bubble Sort
+- Insertion Sort
+- Merge Sort
+
+---
+
+## Utility Functions
+
+- **`swap(a, b)`** – Swap two elements.  
+- **`is_sorted(arr)`** – Check if an array is sorted.  
+- **`reverse(arr)`** – Reverse the elements of a list. Allows above sorting functions
+to sort in descending order, if desired.
+
+---
+
+## Installation
+
+```bash
+pip install sorting-suite

sorting_suite-1.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+sorting_suite/__init__.py,sha256=MuPClu8qmQeu7hk4bDBSnksYsvJOh2oRbovUlbxSNcw,544
+sorting_suite/sorting.py,sha256=zu-Th-xdiyRbwpCLaVGfarYWX3mr6vihB0pA2ros2iQ,5372
+sorting_suite/testing.py,sha256=CdpKSJdJPfkDGjSxfkaPJ-0JA2yRA7piwu-eE9Diki4,1589
+sorting_suite-1.0.1.dist-info/licenses/LICENSE,sha256=VnhoJXSrJmUmafjcQIYfxPneQi-1HtdrB1xqlqSkgfA,1091
+sorting_suite-1.0.1.dist-info/METADATA,sha256=kObyXL5pQ0vRlRxk1Sm62Rj_oKUuylCVnY3_pjq_6zs,1526
+sorting_suite-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sorting_suite-1.0.1.dist-info/top_level.txt,sha256=szzy3nC-gOlFPZirat3gXpqDWQ1Yhuv9Hh7xf2oISkg,14
+sorting_suite-1.0.1.dist-info/RECORD,,

sorting_suite-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sorting_suite-1.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Reese Fairchild
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sorting_suite-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+sorting_suite