Update bubble_sort.cpp

Author: hollowcrust

sorting/bubble_sort.cpp

@@ -28,21 +28,30 @@
  * 
  * ## Bubble Sort Algorithm Analysis (Best Case - Worst Case - Average Case)
  * 
+ * ### Best Case
+ * Bubble Sort Best Case Performance. \f$O(n)\f$. However, you
+ * can't get the best status in the code we shared above. This happens on the
+ * optimized bubble sort algorithm. It's right down there.
+ * 
+ * ### Worst Case
  * Bubble Sort Worst Case Performance is \f$O(n^{2})\f$. Why is that? Because if you
  * remember Big O Notation, we were calculating the complexity of the algorithms in
  * the nested loops. The \f$n * (n - 1)\f$ product gives us \f$O(n^{2})\f$ performance. In the
- * worst case all the steps of the cycle will occur. Bubble Sort (Avarage Case)
- * Performance. Bubble Sort is not an optimal algorithm. in average, \f$O(n^{2})\f$
- * performance is taken. Bubble Sort Best Case Performance. \f$O(n)\f$. However, you
- * can't get the best status in the code we shared above. This happens on the
- * optimized bubble sort algorithm. It's right down there.
+ * worst case all the steps of the cycle will occur.
+ * 
+ * ### Average Case
+ * Bubble Sort is not an optimal algorithm. In average, \f$O(n^{2})\f$ performance is taken. 
+ * 
+ * @author [Deepak](https://github.com/Deepak-j-p)
+ * @author [Nguyen Phuc Chuong](https://github.com/hollowcrust)
  */
 
-#include <cassert>  /// for assert
-#include <iostream> /// for IO implementations
-#include <string>   /// for std::string
-#include <utility>  /// for std::pair, std::swap
-#include <vector>   /// for std::vector, std::vector::push_back, std::vector::size
+#include <algorithm> /// for std::is_sorted
+#include <cassert>   /// for assert
+#include <iostream>  /// for IO implementations
+#include <string>    /// for std::string
+#include <utility>   /// for std::pair, std::swap
+#include <vector>    /// for std::vector, std::vector::push_back, std::vector::size
 
 /**
  * @namespace sorting
@@ -86,33 +95,33 @@ std::vector<T> bubble_sort(std::vector<T>& array) {
  */
 static void test() {
   std::vector<int> vec_1 = {3, 1, -9, 0};
-  std::vector<int> sorted_1 = {-9, 0, 1, 3};
+  std::vector<int> sorted_1 = sorting::bubble_sort::bubble_sort(vec_1);
 
   std::vector<int> vec_2 = {3};
-  std::vector<int> sorted_2 = {3};
+  std::vector<int> sorted_2 = sorting::bubble_sort::bubble_sort(vec_2);
 
   std::vector<int> vec_3 = {10, 10, 10, 10, 10};
-  std::vector<int> sorted_3 = {10, 10, 10, 10, 10};
+  std::vector<int> sorted_3 = sorting::bubble_sort::bubble_sort(vec_3);
 
   std::vector<float> vec_4 = {1234, -273.1, 23, 150, 1234, 1555.55, -2000};
-  std::vector<float> sorted_4 = {-2000, -273.1, 23, 150, 1234, 1234, 1555.55};
+  std::vector<float> sorted_4 = sorting::bubble_sort::bubble_sort(vec_4);
 
   std::vector<char> vec_5 = {'z', 'Z', 'a', 'B', ' ', 'c', 'a'};
-  std::vector<char> sorted_5 = {' ', 'B', 'Z', 'a', 'a', 'c', 'z'};
+  std::vector<char> sorted_5 = sorting::bubble_sort::bubble_sort(vec_5);
 
   std::vector<std::string> vec_6 = {"Hello", "hello", "Helo", "Hi", "hehe"};
-  std::vector<std::string> sorted_6 = {"Hello", "Helo", "Hi", "hehe", "hello"};
+  std::vector<std::string> sorted_6 = sorting::bubble_sort::bubble_sort(vec_6);
 
   std::vector<std::pair<int, char>> vec_7 = {{10, 'c'}, {2, 'z'}, {10, 'a'}, {0, 'b'}, {-1, 'z'}};
-  std::vector<std::pair<int, char>> sorted_7 = {{-1, 'z'}, {0, 'b'}, {2, 'z'}, {10, 'a'}, {10, 'c'}};
+  std::vector<std::pair<int, char>> sorted_7 = sorting::bubble_sort::bubble_sort(vec_7);
 
-  assert((sorting::bubble_sort::bubble_sort(vec_1) == sorted_1));
-  assert((sorting::bubble_sort::bubble_sort(vec_2) == sorted_2));
-  assert((sorting::bubble_sort::bubble_sort(vec_3) == sorted_3));
-  assert((sorting::bubble_sort::bubble_sort(vec_4) == sorted_4));
-  assert((sorting::bubble_sort::bubble_sort(vec_5) == sorted_5));
-  assert((sorting::bubble_sort::bubble_sort(vec_6) == sorted_6));
-  assert((sorting::bubble_sort::bubble_sort(vec_7) == sorted_7));
+  assert(std::is_sorted(sorted_1.begin(), sorted_1.end()));
+  assert(std::is_sorted(sorted_2.begin(), sorted_2.end()));
+  assert(std::is_sorted(sorted_3.begin(), sorted_3.end()));
+  assert(std::is_sorted(sorted_4.begin(), sorted_4.end()));
+  assert(std::is_sorted(sorted_5.begin(), sorted_5.end()));
+  assert(std::is_sorted(sorted_6.begin(), sorted_6.end()));
+  assert(std::is_sorted(sorted_7.begin(), sorted_7.end()));
 }
 
 /**