added sorting algos to namespace sorting

sorting/non_recursive_merge_sort.cpp

@@ -8,27 +8,28 @@
 #include <iostream>
 #include <utility>  // for std::move & std::remove_reference_t
 
-template <class Iterator>
-void merge(Iterator, Iterator, const Iterator, char[]);
-/// bottom-up merge sort which sorts elements in a non-decreasing order
-/**
- * sorts elements non-recursively by breaking them into small segments, merging
- * adjacent segments into larger sorted segments, then increasing the sizes of
- * segments by factors of 2 and repeating the same process.
+namespace sorting {
+    template <class Iterator>
+    void merge(Iterator, Iterator, const Iterator, char[]);
+    /// bottom-up merge sort which sorts elements in a non-decreasing order
+    /**
+     * sorts elements non-recursively by breaking them into small segments,
+     * merging adjacent segments into larger sorted segments, then increasing
+     * the sizes of segments by factors of 2 and repeating the same process.
      * best-case = worst-case = O(n log(n))
      * @param first points to the first element
      * @param last points to 1-step past the last element
      * @param n the number of elements
      */
-template <class Iterator>
-void non_recursive_merge_sort(const Iterator first, const Iterator last,
+    template <class Iterator>
+    void non_recursive_merge_sort(const Iterator first, const Iterator last,
                                   const size_t n) {
         // create a buffer large enough to store all elements
         // dynamically allocated to comply with cpplint
         char* buffer = new char[n * sizeof(*first)];
-    // buffer size can be optimized to largest power of 2 less than n elements
-    // divide the container into equally-sized segments whose length start at 1
-    // and keeps increasing by factors of 2
+        // buffer size can be optimized to largest power of 2 less than n
+        // elements divide the container into equally-sized segments whose
+        // length start at 1 and keeps increasing by factors of 2
         for (size_t length(1); length < n; length <<= 1) {
             // merge adjacent segments whose number is n / (length * 2)
             Iterator left(first);
@@ -43,19 +44,20 @@ void non_recursive_merge_sort(const Iterator first, const Iterator last,
                 merge(left, left + length, last, buffer);
         }
         delete[] buffer;
-}
-/// merges 2 sorted adjacent segments into a larger sorted segment
-/**
+    }
+    /// merges 2 sorted adjacent segments into a larger sorted segment
+    /**
      * best-case = worst-case = O(n)
      * @param l points to the left part
      * @param r points to the right part, end of left part
      * @param e points to end of right part
      * @param b points at the buffer
      */
-template <class Iterator>
-void merge(Iterator l, Iterator r, const Iterator e, char b[]) {
+    template <class Iterator>
+    void merge(Iterator l, Iterator r, const Iterator e, char b[]) {
         // create 2 pointers to point at the buffer
-    auto p(reinterpret_cast<std::remove_reference_t<decltype(*l)>*>(b)), c(p);
+        auto p(reinterpret_cast<std::remove_reference_t<decltype(*l)>*>(b)),
+            c(p);
         // move the left part of the segment
         for (Iterator t(l); r != t; ++t) *p++ = std::move(*t);
         // while neither the buffer nor the right part has been exhausted
@@ -66,25 +68,29 @@ void merge(Iterator l, Iterator r, const Iterator e, char b[]) {
         while (e != r) *l++ = std::move(*r++);
         // while the buffer hasn't bee exhausted, move it back
         while (c != p) *l++ = std::move(*c++);
-}
-/// bottom-up merge sort which sorts elements in a non-decreasing order
-/**
+    }
+    /// bottom-up merge sort which sorts elements in a non-decreasing order
+    /**
      * @param first points to the first element
      * @param n the number of elements
      */
-template <class Iterator>
-void non_recursive_merge_sort(const Iterator first, const size_t n) {
+    template <class Iterator>
+    void non_recursive_merge_sort(const Iterator first, const size_t n) {
         non_recursive_merge_sort(first, first + n, n);
-}
-/// bottom-up merge sort which sorts elements in a non-decreasing order
-/**
+    }
+    /// bottom-up merge sort which sorts elements in a non-decreasing order
+    /**
      * @param first points to the first element
      * @param last points to 1-step past the last element
      */
-template <class Iterator>
-void non_recursive_merge_sort(const Iterator first, const Iterator last) {
+    template <class Iterator>
+    void non_recursive_merge_sort(const Iterator first, const Iterator last) {
         non_recursive_merge_sort(first, last, last - first);
-}
+    }
+
+}  // namespace sorting
+
+using sorting::non_recursive_merge_sort;
 
 int main(int argc, char** argv) {
     int size;

sorting/quick_sort.cpp

@@ -24,7 +24,8 @@
 #include <cstdlib>
 #include <iostream>
 
-/**
+namespace sorting {
+    /**
      *      This function takes last element as pivot, places
      *      the pivot element at its correct position in sorted
      *      array, and places all smaller (smaller than pivot)
@@ -33,7 +34,7 @@
      *
      */
 
-int partition(int arr[], int low, int high) {
+    int partition(int arr[], int low, int high) {
         int pivot = arr[high];  // taking the last element as pivot
         int i = (low - 1);      // Index of smaller element
 
@@ -51,21 +52,25 @@ int partition(int arr[], int low, int high) {
         arr[i + 1] = arr[high];
         arr[high] = temp;
         return (i + 1);
-}
+    }
 
-/**
+    /**
      *      The main function that implements QuickSort
      *      arr[] --> Array to be sorted,
      *      low --> Starting index,
      *      high --> Ending index
      */
-void quickSort(int arr[], int low, int high) {
+    void quickSort(int arr[], int low, int high) {
         if (low < high) {
             int p = partition(arr, low, high);
             quickSort(arr, low, p - 1);
             quickSort(arr, p + 1, high);
         }
-}
+    }
+
+}  // namespace sorting
+
+using sorting::quickSort;
 
 // prints the array after sorting
 void show(int arr[], int size) {