Now code is applicable for generic data types

Author: rohleet

sorting/bubble_sort_optimized.cpp

@@ -1,11 +1,10 @@
 /**
  * @file bubble_sort.cpp
- * @brief Implementation of the Bubble Sort algorithm with self-tests.
+ * @brief Generic implementation of the Bubble Sort algorithm with self-tests.
  *
- * This file contains an implementation of the bubble sort algorithm
- * inside the `sorting` namespace. It includes an optimized version
- * of bubble sort that reduces the number of passes when the input
- * is already sorted or becomes sorted before completing all iterations.
+ * This file contains a template-based implementation of the bubble sort algorithm
+ * inside the `sorting` namespace. It supports sorting of any container
+ * holding elements that can be compared using the `>` operator.
  *
  * Additionally, it contains a set of self-tests to verify correctness
  * using the C++ standard library's `assert` mechanism.
@@ -15,78 +14,107 @@
  * std::vector<int> nums = {5, 4, 3, 2, 1};
  * sorting::bubble_sort(nums);
  * // nums becomes {1, 2, 3, 4, 5}
+ *
+ * std::vector<std::string> words = {"apple", "banana", "cherry"};
+ * sorting::bubble_sort(words);
+ * // words becomes {"apple", "banana", "cherry"}
  * @endcode
  *
  * @author Rohith A K
- * @date 2025-09-25
+ * @date 2025-09-30
  */
 
-#include <cassert>   /// for assert
-#include <iostream>  /// for IO operations
-#include <utility>   /// for std::swap
-#include <vector>    /// for std::vector
+#include <cassert>   ///< for assert
+#include <iostream>  ///< for IO operations
+#include <utility>   ///< for std::swap
+#include <vector>    ///< for std::vector
+#include <string>    ///< for std::string
 
 namespace sorting {
 
 /**
- * @brief Sorts the given vector using the bubble sort algorithm.
+ * @brief Sorts the given container using the bubble sort algorithm.
  *
  * This optimized bubble sort reduces the number of passes in average cases
- * by checking if the array is already sorted during each pass.
+ * by checking if the container is already sorted during each pass.
  *
- * @param nums the vector of integers to be sorted
- * @return reference to the sorted vector
+ * @tparam Container Type of the container (e.g., std::vector<T>)
+ * @param cont The container to be sorted
+ * @return Reference to the sorted container
  */
-std::vector<int>& bubble_sort(std::vector<int>& nums) {
-  for (std::size_t i = 0; i < nums.size() - 1; i++) {
-    bool swapped = false;
-    for (std::size_t j = 0; j < nums.size() - 1 - i; j++) {
-      if (nums[j] > nums[j + 1]) {
-        std::swap(nums[j], nums[j + 1]);
-        swapped = true;
-      }
-    }
-    if (!swapped) {
-      break;
+template <typename Container>
+Container& bubble_sort(Container& cont) {
+    if (cont.size() < 2) return cont;  // handle empty or single-element case
+
+    for (std::size_t i = 0; i < cont.size() - 1; ++i) {
+        bool swapped = false;
+        for (std::size_t j = 0; j < cont.size() - 1 - i; ++j) {
+            if (cont[j] > cont[j + 1]) {
+                std::swap(cont[j], cont[j + 1]);
+                swapped = true;
+            }
+        }
+        if (!swapped) break;
     }
-  }
-  return nums;
+    return cont;
 }
 
 }  // namespace sorting
 
 /**
- * @brief Self-test implementations of the bubble_sort function.
- *
- * Runs a set of predefined test cases using `assert` to ensure
- * the correctness of the bubble_sort implementation.
- *
- * @returns void
+ * @brief Self-test implementations of the generic bubble_sort function.
  */
 static void tests() {
-  std::vector<int> v1 = {2, 8, 1, 6, 2, 0, 3, 6};
-  const std::vector<int> expected1 = {0, 1, 2, 2, 3, 6, 6, 8};
-  assert(sorting::bubble_sort(v1) == expected1);
+    // Integer test cases
+    std::vector<int> v1 = {2, 8, 1, 6, 2, 0, 3, 6};
+    const std::vector<int> expected1 = {0, 1, 2, 2, 3, 6, 6, 8};
+    assert(sorting::bubble_sort(v1) == expected1);
+
+    std::vector<int> v2 = {5, 4, 3, 2, 1};
+    const std::vector<int> expected2 = {1, 2, 3, 4, 5};
+    assert(sorting::bubble_sort(v2) == expected2);
+
+    std::vector<int> v3 = {1, 2, 3, 4, 5};
+    const std::vector<int> expected3 = {1, 2, 3, 4, 5};
+    assert(sorting::bubble_sort(v3) == expected3);
 
-  std::vector<int> v2 = {5, 4, 3, 2, 1};
-  const std::vector<int> expected2 = {1, 2, 3, 4, 5};
-  assert(sorting::bubble_sort(v2) == expected2);
+    // Negative numbers
+    std::vector<int> v4 = {-5, -1, -3, -2, -4};
+    const std::vector<int> expected4 = {-5, -4, -3, -2, -1};
+    assert(sorting::bubble_sort(v4) == expected4);
 
-  std::vector<int> v3 = {1, 2, 3, 4, 5};
-  const std::vector<int> expected3 = {1, 2, 3, 4, 5};
-  assert(sorting::bubble_sort(v3) == expected3);
+    // Mixed negative and positive
+    std::vector<int> v5 = {-1, 0, 1, -2, 2};
+    const std::vector<int> expected5 = {-2, -1, 0, 1, 2};
+    assert(sorting::bubble_sort(v5) == expected5);
 
-  std::cout << "All tests have successfully passed!\n";
+    // Empty vector
+    std::vector<int> v6 = {};
+    const std::vector<int> expected6 = {};
+    assert(sorting::bubble_sort(v6) == expected6);
+
+    // Double test case
+    std::vector<double> vd = {3.5, 2.1, 4.8, 1.2};
+    const std::vector<double> expectedd = {1.2, 2.1, 3.5, 4.8};
+    assert(sorting::bubble_sort(vd) == expectedd);
+
+    // String test case
+    std::vector<std::string> vs = {"apple", "banana", "cherry", "apricot"};
+    const std::vector<std::string> expecteds = {"apple", "apricot", "banana", "cherry"};
+    assert(sorting::bubble_sort(vs) == expecteds);
+
+    // Char test case
+    std::vector<char> vc = {'z', 'b', 'a', 'd', 'c'};
+    const std::vector<char> expectedc = {'a', 'b', 'c', 'd', 'z'};
+    assert(sorting::bubble_sort(vc) == expectedc);
+
+    std::cout << "All generic tests have successfully passed!\n";
 }
 
 /**
  * @brief Main function
- *
- * Executes the self-test suite for bubble_sort.
- *
- * @returns 0 on successful execution
  */
 int main() {
-  tests();  // run self-test implementations
-  return 0;
+    tests();
+    return 0;
 }