Merge pull request #18 from BjornMelin/feat-0.1.0-python-add-sorting-algorithms

Author: BjornMelin

README.md

@@ -92,13 +92,47 @@ algorithms-and-data-structures/
  ├── README.md
  ├── algorithms/
  │ ├── sorting/
+ │ │ ├── quick_sort.py
+ │ │ ├── merge_sort.py
+ │ │ ├── heap_sort.py
+ │ │ ├── bubble_sort.py
+ │ │ ├── selection_sort.py
+ │ │ ├── insertion_sort.py
+ │ │ ├── radix_sort.py
+ │ │ ├── counting_sort.py
+ │ │ ├── bucket_sort.py
+ │ │ └── tim_sort.py
  │ ├── searching/
+ │ │ ├── binary_search.py
+ │ │ └── linear_search.py
  │ └── graph/
+ │ ├── dfs.py
+ │ └── bfs.py
  ├── data_structures/
  │ ├── linear/
+ │ │ ├── linked_list.py
+ │ │ ├── stack.py
+ │ │ └── queue.py
  │ ├── trees/
+ │ │ ├── binary_tree.py
+ │ │ └── avl_tree.py
  │ └── graphs/
- └── tests/
+ │ └── graph.py
+ ├── tests/
+ │ ├── algorithms/
+ │ │ ├── test_quick_sort.py
+ │ │ ├── test_merge_sort.py
+ │ │ ├── test_heap_sort.py
+ │ │ ├── test_bubble_sort.py
+ │ │ ├── test_selection_sort.py
+ │ │ ├── test_insertion_sort.py
+ │ │ ├── test_radix_sort.py
+ │ │ ├── test_counting_sort.py
+ │ │ ├── test_bucket_sort.py
+ │ │ └── test_tim_sort.py
+ │ └── data_structures/
+ ├── requirements.txt
+ └── setup.py
 ```
 
 </details>
@@ -149,6 +183,13 @@ python -m pytest
 | Binary Search | Searching | ✅ | ✅ | O(log n) |
 | DFS | Graph | ✅ | ✅ | O(V + E) |
 | BFS | Graph | ✅ | ✅ | O(V + E) |
+| Bubble Sort | Sorting | ❌ | ✅ | O(n^2) |
+| Selection Sort| Sorting | ❌ | ✅ | O(n^2) |
+| Insertion Sort| Sorting | ❌ | ✅ | O(n^2) |
+| Radix Sort | Sorting | ❌ | ✅ | O(nk) |
+| Counting Sort | Sorting | ❌ | ✅ | O(n + k) |
+| Bucket Sort | Sorting | ❌ | ✅ | O(n + k) |
+| Tim Sort | Sorting | ❌ | ✅ | O(n log n) |
 
 ## 🤝 Contributing
 

python/algorithms/sorting/bubble_sort.py

@@ -0,0 +1,39 @@
+"""
+Bubble Sort Algorithm Implementation
+Author: Bjorn Melin
+Date: 1/28/2025
+
+Bubble Sort is a simple sorting algorithm that repeatedly steps through the list, 
+compares adjacent elements and swaps them if they are in the wrong order. 
+The pass through the list is repeated until the list is sorted.
+
+Time Complexity:
+- Best Case: O(n) when the array is already sorted
+- Average Case: O(n^2)
+- Worst Case: O(n^2)
+
+Space Complexity: O(1)
+"""
+
+from typing import List
+
+def bubble_sort(arr: List[int]) -> List[int]:
+ """
+ Sorts an array of integers using the Bubble Sort algorithm.
+
+ Args:
+ arr (List[int]): The list of integers to be sorted.
+
+ Returns:
+ List[int]: The sorted list of integers.
+ """
+ n = len(arr)
+ for i in range(n):
+ swapped = False
+ for j in range(0, n-i-1):
+ if arr[j] > arr[j+1]:
+ arr[j], arr[j+1] = arr[j+1], arr[j]
+ swapped = True
+ if not swapped:
+ break
+ return arr

python/algorithms/sorting/bubble_sort/README.md

@@ -0,0 +1,85 @@
+# Bubble Sort Algorithm
+
+## Table of Contents
+- [Introduction](#introduction)
+- [Algorithm Explanation](#algorithm-explanation)
+- [Pseudocode](#pseudocode)
+- [Time and Space Complexity](#time-and-space-complexity)
+- [Mermaid Diagram](#mermaid-diagram)
+- [Testing Results](#testing-results)
+- [Usage Guide](#usage-guide)
+
+## Introduction
+Bubble Sort is a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. The pass through the list is repeated until the list is sorted.
+
+## Algorithm Explanation
+1. Start at the beginning of the list.
+2. Compare the first two elements.
+3. If the first element is greater than the second, swap them.
+4. Move to the next pair of elements and repeat step 3.
+5. Continue this process until the end of the list.
+6. Repeat the entire process for the remaining unsorted elements until the list is sorted.
+
+## Pseudocode
+```
+procedure bubbleSort(A: list of sortable items)
+ n := length(A)
+ repeat
+ swapped := false
+ for i := 1 to n-1 inclusive do
+ if A[i-1] > A[i] then
+ swap(A[i-1], A[i])
+ swapped := true
+ end if
+ end for
+ n := n - 1
+ until not swapped
+end procedure
+```
+
+## Time and Space Complexity
+- **Best Case:** O(n) when the array is already sorted
+- **Average Case:** O(n^2)
+- **Worst Case:** O(n^2)
+- **Space Complexity:** O(1)
+
+## Mermaid Diagram
+```mermaid
+graph TD
+ A[Start] --> B[Initialize n to length of list]
+ B --> C[Repeat until no swaps]
+ C --> D[Set swapped to false]
+ D --> E[For i from 1 to n-1]
+ E --> F{A[i-1] > A[i]?}
+ F -- Yes --> G[Swap A[i-1] and A[i]]
+ G --> H[Set swapped to true]
+ F -- No --> I[Continue]
+ H --> I
+ I --> J[Decrease n by 1]
+ J --> C
+ C --> K[End]
+```
+
+## Testing Results
+| Test Case | Input | Expected Output | Actual Output |
+|--------------------------|----------------------|-----------------------|-----------------------|
+| Empty List | [] | [] | [] |
+| Single Element | [1] | [1] | [1] |
+| Already Sorted | [1, 2, 3, 4, 5] | [1, 2, 3, 4, 5] | [1, 2, 3, 4, 5] |
+| Reverse Sorted | [5, 4, 3, 2, 1] | [1, 2, 3, 4, 5] | [1, 2, 3, 4, 5] |
+| Duplicates | [3, 1, 2, 3, 1] | [1, 1, 2, 3, 3] | [1, 1, 2, 3, 3] |
+| Large Dataset | [1000, 999, ..., 1] | [1, 2, ..., 1000] | [1, 2, ..., 1000] |
+
+## Usage Guide
+To use the Bubble Sort algorithm, follow these steps:
+1. Import the `bubble_sort` function from the `bubble_sort` module.
+2. Pass the list of integers to be sorted as an argument to the `bubble_sort` function.
+3. The function will return the sorted list of integers.
+
+```python
+from bubble_sort import bubble_sort
+
+arr = [64, 34, 25, 12, 22, 11, 90]
+sorted_arr = bubble_sort(arr)
+print("Sorted array is:", sorted_arr)
+```

python/algorithms/sorting/bucket_sort.py

@@ -0,0 +1,51 @@
+"""
+Bucket Sort Algorithm Implementation
+Author: Bjorn Melin
+Date: 1/28/2025
+
+Bucket Sort is a distribution sort algorithm that works by distributing the elements 
+of an array into a number of buckets. Each bucket is then sorted individually, either 
+using a different sorting algorithm or by recursively applying the bucket sort algorithm.
+
+Time Complexity:
+- Best Case: O(n + k) where k is the number of buckets
+- Average Case: O(n + k)
+- Worst Case: O(n^2) when all elements are placed in a single bucket
+
+Space Complexity: O(n + k)
+"""
+
+from typing import List
+
+def bucket_sort(arr: List[int]) -> List[int]:
+ """
+ Sorts an array of integers using the Bucket Sort algorithm.
+
+ Args:
+ arr (List[int]): The list of integers to be sorted.
+
+ Returns:
+ List[int]: The sorted list of integers.
+ """
+ if len(arr) == 0:
+ return arr
+
+ # Determine minimum and maximum values
+ min_value = min(arr)
+ max_value = max(arr)
+
+ # Initialize buckets
+ bucket_count = len(arr)
+ buckets = [[] for _ in range(bucket_count)]
+
+ # Distribute input array values into buckets
+ for i in range(len(arr)):
+ index = int((arr[i] - min_value) / (max_value - min_value + 1) * bucket_count)
+ buckets[index].append(arr[i])
+
+ # Sort each bucket and concatenate the results
+ sorted_array = []
+ for bucket in buckets:
+ sorted_array.extend(sorted(bucket))
+
+ return sorted_array

python/algorithms/sorting/bucket_sort/README.md

@@ -0,0 +1,86 @@
+# Bucket Sort Algorithm
+
+## Table of Contents
+- [Introduction](#introduction)
+- [Algorithm Explanation](#algorithm-explanation)
+- [Pseudocode](#pseudocode)
+- [Time and Space Complexity](#time-and-space-complexity)
+- [Mermaid Diagram](#mermaid-diagram)
+- [Testing Results](#testing-results)
+- [Usage Guide](#usage-guide)
+
+## Introduction
+Bucket Sort is a distribution sort algorithm that works by distributing the elements 
+of an array into a number of buckets. Each bucket is then sorted individually, either 
+using a different sorting algorithm or by recursively applying the bucket sort algorithm.
+
+## Algorithm Explanation
+1. Determine the minimum and maximum values in the array.
+2. Initialize a number of empty buckets.
+3. Distribute the elements of the array into the buckets based on a calculated index.
+4. Sort each bucket individually.
+5. Concatenate the sorted buckets to form the final sorted array.
+
+## Pseudocode
+```
+procedure bucketSort(A: list of sortable items)
+ n := length(A)
+ if n = 0 then
+ return A
+ end if
+ min_value := min(A)
+ max_value := max(A)
+ bucket_count := n
+ buckets := array of empty lists of size bucket_count
+ for i := 0 to n-1 do
+ index := (A[i] - min_value) / (max_value - min_value + 1) * bucket_count
+ buckets[index].append(A[i])
+ end for
+ sorted_array := empty list
+ for each bucket in buckets do
+ sorted_array.extend(sort(bucket))
+ end for
+ return sorted_array
+end procedure
+```
+
+## Time and Space Complexity
+- **Best Case:** O(n + k) where k is the number of buckets
+- **Average Case:** O(n + k)
+- **Worst Case:** O(n^2) when all elements are placed in a single bucket
+- **Space Complexity:** O(n + k)
+
+## Mermaid Diagram
+```mermaid
+graph TD
+ A[Start] --> B[Determine min and max values]
+ B --> C[Initialize empty buckets]
+ C --> D[Distribute elements into buckets]
+ D --> E[Sort each bucket]
+ E --> F[Concatenate sorted buckets]
+ F --> G[End]
+```
+
+## Testing Results
+| Test Case | Input | Expected Output | Actual Output |
+|--------------------------|----------------------|-----------------------|-----------------------|
+| Empty List | [] | [] | [] |
+| Single Element | [1] | [1] | [1] |
+| Already Sorted | [1, 2, 3, 4, 5] | [1, 2, 3, 4, 5] | [1, 2, 3, 4, 5] |
+| Reverse Sorted | [5, 4, 3, 2, 1] | [1, 2, 3, 4, 5] | [1, 2, 3, 4, 5] |
+| Duplicates | [3, 1, 2, 3, 1] | [1, 1, 2, 3, 3] | [1, 1, 2, 3, 3] |
+| Large Dataset | [1000, 999, ..., 1] | [1, 2, ..., 1000] | [1, 2, ..., 1000] |
+
+## Usage Guide
+To use the Bucket Sort algorithm, follow these steps:
+1. Import the `bucket_sort` function from the `bucket_sort` module.
+2. Pass the list of integers to be sorted as an argument to the `bucket_sort` function.
+3. The function will return the sorted list of integers.
+
+```python
+from bucket_sort import bucket_sort
+
+arr = [64, 34, 25, 12, 22, 11, 90]
+sorted_arr = bucket_sort(arr)
+print("Sorted array is:", sorted_arr)
+```

python/algorithms/sorting/counting_sort.py

@@ -0,0 +1,57 @@
+"""
+Counting Sort Algorithm Implementation
+Author: Bjorn Melin
+Date: 1/28/2025
+
+Counting Sort is an integer sorting algorithm that operates by counting the 
+number of objects that have distinct key values (kind of hashing). It is not 
+a comparison-based sorting algorithm and its time complexity is O(n + k), 
+where n is the number of elements in the input array and k is the range of 
+the input.
+
+Time Complexity:
+- Best Case: O(n + k)
+- Average Case: O(n + k)
+- Worst Case: O(n + k)
+
+Space Complexity: O(n + k)
+"""
+
+from typing import List
+
+def counting_sort(arr: List[int]) -> List[int]:
+ """
+ Sorts an array of integers using the Counting Sort algorithm.
+
+ Args:
+ arr (List[int]): The list of integers to be sorted.
+
+ Returns:
+ List[int]: The sorted list of integers.
+ """
+ if not arr:
+ return []
+
+ max_val = max(arr)
+ min_val = min(arr)
+ range_of_elements = max_val - min_val + 1
+
+ # Initialize count array
+ count = [0] * range_of_elements
+ output = [0] * len(arr)
+
+ # Store the count of each element
+ for num in arr:
+ count[num - min_val] += 1
+
+ # Change count[i] so that count[i] now contains the actual
+ # position of this element in the output array
+ for i in range(1, len(count)):
+ count[i] += count[i - 1]
+
+ # Build the output array
+ for num in reversed(arr):
+ output[count[num - min_val] - 1] = num
+ count[num - min_val] -= 1
+
+ return output