fix: add <cstdint> to sorting/**

Author: realstealthninja

sorting/cycle_sort.cpp

@@ -13,6 +13,7 @@
 
 #include <algorithm>  /// for std::is_sorted, std::swap
 #include <cassert>    /// for assert
+#include <cstdint>    /// for integral typedefs
 #include <iostream>   /// for io operations
 #include <vector>     /// for std::vector
 

sorting/dnf_sort.cpp

@@ -12,6 +12,7 @@
 
 #include <algorithm>  /// for std::is_sorted
 #include <cassert>    /// for assert
+#include <cstdint>    /// for integral typedefs
 #include <iostream>   /// for std::swap and io operations
 #include <vector>     /// for std::vector
 

sorting/quick_sort.cpp

@@ -26,6 +26,7 @@
 
 #include <algorithm>  /// for std::is_sorted
 #include <cassert>    /// for std::assert
+#include <cstdint>    /// for integral typedefs
 #include <ctime>      /// for std::time
 #include <iostream>   /// for IO operations
 #include <vector>     /// for std::vector

sorting/radix_sort2.cpp

@@ -23,8 +23,10 @@
  */
 
 /// header files
+
 #include <algorithm>  /// for collection of functions
 #include <cassert>  /// for a macro called assert which can be used to verify assumptions
+#include <cstdint>   /// for integral typedefs
 #include <iostream>  /// for io operations
 #include <vector>    /// for std::vector
 

sorting/recursive_bubble_sort.cpp

@@ -1,20 +1,23 @@
 /**
  * @file
  * @author [Aditya Prakash](https://adityaprakash.tech)
- * @brief This is an implementation of a recursive version of the [Bubble sort algorithm](https://www.geeksforgeeks.org/recursive-bubble-sort/)
+ * @brief This is an implementation of a recursive version of the [Bubble sort
+ algorithm](https://www.geeksforgeeks.org/recursive-bubble-sort/)
  *
  * @details
  * The working principle of the Bubble sort algorithm.
 
- * Bubble sort is a simple sorting algorithm used to rearrange a set of ascending or descending order elements.
- * Bubble sort gets its name from the fact that data "bubbles" to the top of the dataset.
- 
+ * Bubble sort is a simple sorting algorithm used to rearrange a set of
+ ascending or descending order elements.
+ * Bubble sort gets its name from the fact that data "bubbles" to the top of the
+ dataset.
+
  * ### Algorithm
 
  * What is Swap?
 
  * Swapping two numbers means that we interchange their values.
- * Often, an additional variable is required for this operation. 
+ * Often, an additional variable is required for this operation.
  * This is further illustrated in the following:
 
  * void swap(int x, int y){
@@ -26,15 +29,19 @@
  * The above process is a typical displacement process.
  * When we assign a value to x, the old value of x is lost.
  * That's why we create a temporary variable z to store the initial value of x.
- * z is further used to assign the initial value of x to y, to complete swapping.
+ * z is further used to assign the initial value of x to y, to complete
+ swapping.
 
  * Recursion
 
- * While the recursive method does not necessarily have advantages over iterative
+ * While the recursive method does not necessarily have advantages over
+ iterative
  * versions, but it is useful to enhance the understanding of the algorithm and
  * recursion itself. In Recursive Bubble sort algorithm, we firstly call the
- * function on the entire array, and for every subsequent function call, we exclude
- * the last element. This fixes the last element for that sub-array.Formally, for
+ * function on the entire array, and for every subsequent function call, we
+ exclude
+ * the last element. This fixes the last element for that sub-array.Formally,
+ for
  * `ith` iteration, we consider elements up to n-i, where n is the number of
  * elements in the array. Exit condition: n==1; i.e. the sub-array contains only
  * one element.
@@ -43,16 +50,19 @@
  * Time complexity: O(n) best case; O(n²) average case; O(n²) worst case
  * Space complexity: O(n)
 
- * We need to traverse the array `n * (n-1)` times. However, if the entire array is
- * already sorted, then we need to traverse it only once. Hence, O(n) is the best case
+ * We need to traverse the array `n * (n-1)` times. However, if the entire array
+ is
+ * already sorted, then we need to traverse it only once. Hence, O(n) is the
+ best case
  * complexity
 */
 
-#include <cassert>   /// for assert
-#include <iostream>  /// for IO operations
-#include <vector>    /// for std::vector
-#include <array>     /// for std::array
-#include <algorithm> /// for std::is_sorted
+#include <algorithm>  /// for std::is_sorted
+#include <array>      /// for std::array
+#include <cassert>    /// for assert
+#include <cstdint>    /// for integral typedefs
+#include <iostream>   /// for IO operations
+#include <vector>     /// for std::vector
 
 /**
  * @namespace sorting
@@ -61,11 +71,11 @@
 namespace sorting {
 
 /**
- * @brief This is an implementation of the recursive_bubble_sort. A vector is passed
- * to the function which is then dereferenced, so that the changes are
+ * @brief This is an implementation of the recursive_bubble_sort. A vector is
+ * passed to the function which is then dereferenced, so that the changes are
  * reflected in the original vector. It also accepts a second parameter of
  * type `int` and name `n`, which is the size of the array.
- * 
+ *
  * @tparam T type of data variables in the array
  * @param nums our array of elements.
  * @param n size of the array
@@ -136,14 +146,13 @@ static void test() {
         std::cout << double_arr[i] << ", ";
     }
     std::cout << std::endl;
-
 }
 
 /**
  * @brief Main function
  * @returns 0 on exit
  */
-int main() { 
+int main() {
     test();  // run self-test implementations
     return 0;
 }

sorting/selection_sort_iterative.cpp

@@ -29,6 +29,7 @@
  *******************************************************************************/
 #include <algorithm>  /// for std::is_sorted
 #include <cassert>    /// for std::assert
+#include <cstdint>    /// for integral typedefs
 #include <iostream>   /// for IO operations
 #include <vector>     /// for std::vector
 

sorting/selection_sort_recursive.cpp

@@ -28,9 +28,10 @@
  */
 
 #include <algorithm>  /// for std::is_sorted
-#include <cassert>    /// for assert
-#include <iostream>   /// for std::swap and io operations
-#include <vector>     /// for std::vector
+#include <cassert>  /// for assert#include <cstdint>    /// for integral typedefs
+#include <cstdint>   /// for integral typedefs
+#include <iostream>  /// for std::swap and io operations
+#include <vector>    /// for std::vector
 
 /**
  * @namespace sorting

sorting/wiggle_sort.cpp

@@ -19,6 +19,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cstdint>  /// for integral typedefs
 #include <ctime>
 #include <iostream>  /// for io operations
 #include <vector>
@@ -50,7 +51,7 @@ namespace wiggle_sort {
  */
 template <typename T>  // this allows to have vectors of ints, double, float,
                        // etc
-                       std::vector<T> wiggleSort(const std::vector<T> &arr) {
+std::vector<T> wiggleSort(const std::vector<T> &arr) {
     uint32_t size = arr.size();
 
     std::vector<T> out(