From b9013d1eb0d20007158af91f2c8773456d56b52b Mon Sep 17 00:00:00 2001 From: Sumukesh Date: Wed, 9 Oct 2024 15:56:47 +0530 Subject: [PATCH] I have changed some code in sorts/bubble_sort.py --- sorts/bubble_sort.py | 135 +++++++++---------------------------------- 1 file changed, 26 insertions(+), 109 deletions(-) diff --git a/sorts/bubble_sort.py b/sorts/bubble_sort.py index bdf85c70dd35..9acb839594ce 100644 --- a/sorts/bubble_sort.py +++ b/sorts/bubble_sort.py @@ -1,51 +1,15 @@ -from typing import Any +from typing import Any, List +def bubble_sort_iterative(collection: List[Any]) -> List[Any]: + """Sorts a collection using the iterative bubble sort algorithm. -def bubble_sort_iterative(collection: list[Any]) -> list[Any]: - """Pure implementation of bubble sort algorithm in Python - - :param collection: some mutable ordered collection with heterogeneous - comparable items inside - :return: the same collection ordered by ascending - - Examples: - >>> bubble_sort_iterative([0, 5, 2, 3, 2]) - [0, 2, 2, 3, 5] - >>> bubble_sort_iterative([]) - [] - >>> bubble_sort_iterative([-2, -45, -5]) - [-45, -5, -2] - >>> bubble_sort_iterative([-23, 0, 6, -4, 34]) - [-23, -4, 0, 6, 34] - >>> bubble_sort_iterative([0, 5, 2, 3, 2]) == sorted([0, 5, 2, 3, 2]) - True - >>> bubble_sort_iterative([]) == sorted([]) - True - >>> bubble_sort_iterative([-2, -45, -5]) == sorted([-2, -45, -5]) - True - >>> bubble_sort_iterative([-23, 0, 6, -4, 34]) == sorted([-23, 0, 6, -4, 34]) - True - >>> bubble_sort_iterative(['d', 'a', 'b', 'e']) == sorted(['d', 'a', 'b', 'e']) - True - >>> bubble_sort_iterative(['z', 'a', 'y', 'b', 'x', 'c']) - ['a', 'b', 'c', 'x', 'y', 'z'] - >>> bubble_sort_iterative([1.1, 3.3, 5.5, 7.7, 2.2, 4.4, 6.6]) - [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7] - >>> bubble_sort_iterative([1, 3.3, 5, 7.7, 2, 4.4, 6]) - [1, 2, 3.3, 4.4, 5, 6, 7.7] - >>> import random - >>> collection_arg = random.sample(range(-50, 50), 100) - >>> bubble_sort_iterative(collection_arg) == sorted(collection_arg) - True - >>> import string - >>> collection_arg = random.choices(string.ascii_letters + string.digits, k=100) - >>> bubble_sort_iterative(collection_arg) == sorted(collection_arg) - True + :param collection: A mutable ordered collection with comparable items. + :return: The same collection ordered in ascending order. """ length = len(collection) - for i in reversed(range(length)): + for i in range(length): swapped = False - for j in range(i): + for j in range(length - 1 - i): if collection[j] > collection[j + 1]: swapped = True collection[j], collection[j + 1] = collection[j + 1], collection[j] @@ -54,77 +18,30 @@ def bubble_sort_iterative(collection: list[Any]) -> list[Any]: return collection -def bubble_sort_recursive(collection: list[Any]) -> list[Any]: - """It is similar iterative bubble sort but recursive. - - :param collection: mutable ordered sequence of elements - :return: the same list in ascending order +def bubble_sort_recursive(collection: List[Any]) -> List[Any]: + """Sorts a collection using the recursive bubble sort algorithm. - Examples: - >>> bubble_sort_recursive([0, 5, 2, 3, 2]) - [0, 2, 2, 3, 5] - >>> bubble_sort_iterative([]) - [] - >>> bubble_sort_recursive([-2, -45, -5]) - [-45, -5, -2] - >>> bubble_sort_recursive([-23, 0, 6, -4, 34]) - [-23, -4, 0, 6, 34] - >>> bubble_sort_recursive([0, 5, 2, 3, 2]) == sorted([0, 5, 2, 3, 2]) - True - >>> bubble_sort_recursive([]) == sorted([]) - True - >>> bubble_sort_recursive([-2, -45, -5]) == sorted([-2, -45, -5]) - True - >>> bubble_sort_recursive([-23, 0, 6, -4, 34]) == sorted([-23, 0, 6, -4, 34]) - True - >>> bubble_sort_recursive(['d', 'a', 'b', 'e']) == sorted(['d', 'a', 'b', 'e']) - True - >>> bubble_sort_recursive(['z', 'a', 'y', 'b', 'x', 'c']) - ['a', 'b', 'c', 'x', 'y', 'z'] - >>> bubble_sort_recursive([1.1, 3.3, 5.5, 7.7, 2.2, 4.4, 6.6]) - [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7] - >>> bubble_sort_recursive([1, 3.3, 5, 7.7, 2, 4.4, 6]) - [1, 2, 3.3, 4.4, 5, 6, 7.7] - >>> import random - >>> collection_arg = random.sample(range(-50, 50), 100) - >>> bubble_sort_recursive(collection_arg) == sorted(collection_arg) - True - >>> import string - >>> collection_arg = random.choices(string.ascii_letters + string.digits, k=100) - >>> bubble_sort_recursive(collection_arg) == sorted(collection_arg) - True + :param collection: A mutable ordered sequence of elements. + :return: The same list in ascending order. """ - length = len(collection) + if len(collection) <= 1: + return collection + + # Perform a single pass of bubble sort swapped = False - for i in range(length - 1): + for i in range(len(collection) - 1): if collection[i] > collection[i + 1]: - collection[i], collection[i + 1] = collection[i + 1], collection[i] swapped = True - - return collection if not swapped else bubble_sort_recursive(collection) + collection[i], collection[i + 1] = collection[i + 1], collection[i] + + if not swapped: + return collection + + return bubble_sort_recursive(collection[:-1]) + [collection[-1]] if __name__ == "__main__": - import doctest - from random import sample - from timeit import timeit - - doctest.testmod() - - # Benchmark: Iterative seems slightly faster than recursive. - num_runs = 10_000 - unsorted = sample(range(-50, 50), 100) - timer_iterative = timeit( - "bubble_sort_iterative(unsorted[:])", globals=globals(), number=num_runs - ) - print("\nIterative bubble sort:") - print(*bubble_sort_iterative(unsorted), sep=",") - print(f"Processing time (iterative): {timer_iterative:.5f}s for {num_runs:,} runs") - - unsorted = sample(range(-50, 50), 100) - timer_recursive = timeit( - "bubble_sort_recursive(unsorted[:])", globals=globals(), number=num_runs - ) - print("\nRecursive bubble sort:") - print(*bubble_sort_recursive(unsorted), sep=",") - print(f"Processing time (recursive): {timer_recursive:.5f}s for {num_runs:,} runs") + # Example usage + sample_list = [5, 3, 8, 6, 2] + print("Iterative Bubble Sort:", bubble_sort_iterative(sample_list.copy())) + print("Recursive Bubble Sort:", bubble_sort_recursive(sample_list.copy()))