Merge branch 'master' into duval

Author: aghoussaini

DIRECTORY.md

@@ -19,6 +19,7 @@
   * [Count Of Set Bits](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/bit_manipulation/count_of_set_bits.cpp)
   * [Count Of Trailing Ciphers In Factorial N](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/bit_manipulation/count_of_trailing_ciphers_in_factorial_n.cpp)
   * [Find Non Repeating Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/bit_manipulation/find_non_repeating_number.cpp)
+  * [Gray Code](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/bit_manipulation/gray_code.cpp)
   * [Hamming Distance](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/bit_manipulation/hamming_distance.cpp)
   * [Next Higher Number With Same Number Of Set Bits](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/bit_manipulation/next_higher_number_with_same_number_of_set_bits.cpp)
   * [Power Of 2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/bit_manipulation/power_of_2.cpp)
@@ -161,6 +162,7 @@
 ## Greedy Algorithms
   * [Boruvkas Minimum Spanning Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/boruvkas_minimum_spanning_tree.cpp)
   * [Dijkstra](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/dijkstra.cpp)
+  * [Gale Shapley](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/gale_shapley.cpp)
   * [Huffman](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/huffman.cpp)
   * [Jump Game](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/jump_game.cpp)
   * [Knapsack](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/knapsack.cpp)
@@ -377,6 +379,7 @@
   * [Pigeonhole Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/pigeonhole_sort.cpp)
   * [Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/quick_sort.cpp)
   * [Quick Sort 3](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/quick_sort_3.cpp)
+  * [Quick Sort Iterative](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/quick_sort_iterative.cpp)
   * [Radix Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/radix_sort.cpp)
   * [Radix Sort2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/radix_sort2.cpp)
   * [Random Pivot Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/random_pivot_quick_sort.cpp)

bit_manipulation/gray_code.cpp

@@ -0,0 +1,113 @@
+/**
+ * @brief Program to generate n-bit [Gray 
+ * code](https://en.wikipedia.org/wiki/Gray_code)
+ * 
+ * @details
+ * Gray code is a binary numeral system
+ * where consecutive values differ in exactly 1 bit.
+ * The following code offers one of many possible Gray codes 
+ * given some pre-determined number of bits.
+ */
+
+#include <bitset>  /// for gray code representation
+#include <cassert>  /// for assert
+#include <iostream>  /// for IO operations
+#include <vector>  /// for vector data structure
+
+/**
+ * @namespace bit_manipulation
+ * @brief Bit manipulation algorithms
+ */
+namespace bit_manipulation {
+/**
+ * @namespace gray_code
+ * @brief Generate n-bit Gray code
+ */
+namespace gray_code {
+/**
+ * @brief The main function to generate n-bit Gray code
+ *
+ * @param n Number of bits
+ * @return A vector that stores the n-bit Gray code
+ */
+std::vector<std::bitset<32>> gray_code_generation(int n) {
+    std::vector<std::bitset<32>> gray_code = {};  // Initialise empty vector
+
+    // No Gray codes for non-positive values of n
+    if (n <= 0) {
+        return gray_code;
+    }
+    
+    int total_codes = 1 << n;  // Number of n-bit gray codes
+
+    for (int i = 0; i < total_codes; i++) {
+        int gray_num = i ^ (i >> 1);  // Gray code formula
+        gray_code.push_back(std::bitset<32>(gray_num));  // Store the value
+    }
+
+    return gray_code;
+} 
+}  // namespace gray_code
+}  // namespace bit_manipulation
+
+/**
+ * @brief Self-test implementation
+ *
+ * @returns void
+ */
+static void test() { 
+    std::vector<std::bitset<32>> gray_code_negative_1 = {};
+
+    std::vector<std::bitset<32>> gray_code_0 = {};
+
+    std::vector<std::bitset<32>> gray_code_1 = {
+        std::bitset<32>(0), std::bitset<32>(1)
+    };
+
+    std::vector<std::bitset<32>> gray_code_2 = {
+        std::bitset<32>(0), std::bitset<32>(1), std::bitset<32>(3), std::bitset<32>(2)
+    };
+
+    std::vector<std::bitset<32>> gray_code_3 = {
+        std::bitset<32>(0), std::bitset<32>(1), std::bitset<32>(3), std::bitset<32>(2),
+        std::bitset<32>(6), std::bitset<32>(7), std::bitset<32>(5), std::bitset<32>(4)
+    };
+
+    std::vector<std::bitset<32>> gray_code_4 = {
+        std::bitset<32>(0), std::bitset<32>(1), std::bitset<32>(3), std::bitset<32>(2),
+        std::bitset<32>(6), std::bitset<32>(7), std::bitset<32>(5), std::bitset<32>(4),
+        std::bitset<32>(12), std::bitset<32>(13), std::bitset<32>(15), std::bitset<32>(14),
+        std::bitset<32>(10), std::bitset<32>(11), std::bitset<32>(9), std::bitset<32>(8)
+    };
+
+    std::vector<std::bitset<32>> gray_code_5 = {
+        std::bitset<32>(0), std::bitset<32>(1), std::bitset<32>(3), std::bitset<32>(2),
+        std::bitset<32>(6), std::bitset<32>(7), std::bitset<32>(5), std::bitset<32>(4),
+        std::bitset<32>(12), std::bitset<32>(13), std::bitset<32>(15), std::bitset<32>(14),
+        std::bitset<32>(10), std::bitset<32>(11), std::bitset<32>(9), std::bitset<32>(8),
+        std::bitset<32>(24), std::bitset<32>(25), std::bitset<32>(27), std::bitset<32>(26),
+        std::bitset<32>(30), std::bitset<32>(31), std::bitset<32>(29), std::bitset<32>(28),
+        std::bitset<32>(20), std::bitset<32>(21), std::bitset<32>(23), std::bitset<32>(22),
+        std::bitset<32>(18), std::bitset<32>(19), std::bitset<32>(17), std::bitset<32>(16)
+    };
+
+    // invalid values for n
+    assert(bit_manipulation::gray_code::gray_code_generation(-1) == gray_code_negative_1);
+    assert(bit_manipulation::gray_code::gray_code_generation(0) == gray_code_0);
+
+    // valid values for n
+    assert(bit_manipulation::gray_code::gray_code_generation(1) == gray_code_1);
+    assert(bit_manipulation::gray_code::gray_code_generation(2) == gray_code_2);
+    assert(bit_manipulation::gray_code::gray_code_generation(3) == gray_code_3);
+    assert(bit_manipulation::gray_code::gray_code_generation(4) == gray_code_4);
+    assert(bit_manipulation::gray_code::gray_code_generation(5) == gray_code_5);
+}
+
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
+int main() {
+    test();  //Run self-test implementation
+    return 0;
+}

data_structures/circular_queue_using_linked_list.cpp

@@ -5,49 +5,65 @@ struct node {
     struct node* next;
 };
 class Queue {
-    node* front=nullptr;
-    node* rear=nullptr;
+    node* front = nullptr;
+    node* rear = nullptr;
 
-public:
-    Queue() = default; 
+    Queue(const Queue&) = delete;
+    Queue& operator=(const Queue&) = delete;
+
+ public:
+    Queue() = default;
+    ~Queue() {
+        while (front) {
+            dequeue();
+        }
+    }
+
+ private:
     void createNode(int val) {
         auto* nn = new node;
         nn->data = val;
         nn->next = nullptr;
         front = nn;
         rear = nn;
     }
+
+ public:
     void enqueue(int val) {
         if (front == nullptr || rear == nullptr) {
             createNode(val);
-        }
-        else {
-            node* nn;
-            nn = new node;
+        } else {
+            node* nn = new node;
             nn->data = val;
             rear->next = nn;
             nn->next = front;
             rear = nn;
         }
     }
     void dequeue() {
-        node* n;
-        n = front;
-        if (n) {
+        if (front == nullptr) {
+            return;
+        }
+        const node* const n = front;
+        if (front == rear) {
+            front = nullptr;
+            rear = nullptr;
+        } else {
             front = front->next;
-            delete n;
+            rear->next = front;
         }
+        delete n;
     }
     void traverse() {
-        node* ptr;
-        ptr = front;
-        if (ptr) {
-            do {
-                std::cout << ptr->data << " ";
-                ptr = ptr->next;
-            } while (ptr != rear->next);
-            std::cout << front->data << std::endl;
+        if (front == nullptr) {
+            return;
         }
+        const node* ptr = front;
+        do {
+            std::cout << ptr->data << ' ';
+            ptr = ptr->next;
+        } while (ptr != front);
+        std::cout << '\n';
     }
 };
 int main(void) {

data_structures/morrisinorder.cpp

@@ -81,12 +81,21 @@ void morrisInorder(Btree *root) {
     }
 }
 
+void deleteAll(const Btree *const root) {
+    if (root) {
+        deleteAll(root->left);
+        deleteAll(root->right);
+        delete root;
+    }
+}
+
 int main() {
     // Testing morrisInorder funtion
     Btree *root = NULL;
     int i;
     for (i = 1; i <= 7; i++) insert(&root, i);
     cout << "Morris Inorder: ";
     morrisInorder(root);
+    deleteAll(root);
     return 0;
 }

dynamic_programming/catalan_numbers.cpp

@@ -1,75 +1,81 @@
-/** Print all the Catalan numbers from 0 to n, n being the user input.
-
- * A Catalan number satifies the following two properties:
- * C(0) = C(1) = 1; C(n) = sum(C(i).C(n-i-1)), from i = 0 to n-1
+/**
+ * @file
+ * @brief Provides utilities to compute Catalan numbers using dynamic
+ programming.
+ * A Catalan numbers satisfy these recurrence relations:
+ * C(0) = C(1) = 1; C(n) = sum(C(i).C(n-i-1)), for i = 0 to n-1
  * Read more about Catalan numbers here:
     https://en.wikipedia.org/wiki/Catalan_number
+    https://oeis.org/A000108/
  */
 
-#include <iostream>
-using namespace std;
-
-int *cat;  // global array to hold catalan numbers
-
-unsigned long int catalan_dp(int n) {
-    /** Using the tabulation technique in dynamic programming,
-        this function computes the first `n+1` Catalan numbers
-
-        Parameter
-        ---------
-        n: The number of catalan numbers to be computed.
+#include <cassert>  /// for assert
+#include <cstdint>  /// for std::uint64_t
+#include <cstdlib>  /// for std::size_t
+#include <numeric>  /// for std::transform_reduce
+#include <vector>   /// for std::vector
 
-        Returns
-        -------
-        cat[n]: An array containing the first `n+1` Catalan numbers
-    */
-
-    // By definition, the first two Catalan numbers are 1
-    cat[0] = cat[1] = 1;
-
-    // Compute the remaining numbers from index 2 to index n, using tabulation
-    for (int i = 2; i <= n; i++) {
-        cat[i] = 0;
-        for (int j = 0; j < i; j++)
-            cat[i] += cat[j] * cat[i - j - 1];  // applying the definition here
+/**
+ * @brief computes and caches Catalan numbers
+ */
+class catalan_numbers {
+    using value_type = std::uint64_t;
+    std::vector<value_type> known{1, 1};
+
+    value_type compute_next() {
+        return std::transform_reduce(known.begin(), known.end(), known.rbegin(),
+                                     static_cast<value_type>(), std::plus<>(),
+                                     std::multiplies<>());
     }
 
-    // Return the result
-    return cat[n];
-}
-
-int main(int argc, char *argv[]) {
-    int n;
-    cout << "Enter n: ";
-    cin >> n;
-
-    cat = new int[n + 1];
-
-    cout << "Catalan numbers from 0 to " << n << " are:\n";
-    for (int i = 0; i <= n; i++) {
-        cout << "catalan (" << i << ") = " << catalan_dp(i) << endl;
-        // NOTE: Since `cat` is a global array, calling `catalan_dp`
-        // repeatedly will not recompute the the values already computed
-        // as in case of pre-computed values, the array will simply return them,
-        // instead of recomputing them.
+    void add() { known.push_back(this->compute_next()); }
+
+ public:
+    /**
+     * @brief computes the n-th Catalan number and updates the cache.
+     * @return the n-th Catalan number
+     */
+    value_type get(std::size_t n) {
+        while (known.size() <= n) {
+            this->add();
+        }
+        return known[n];
     }
-
-    return 0;
+};
+
+void test_catalan_numbers_up_to_20() {
+    // data verified with https://oeis.org/A000108/
+    catalan_numbers cn;
+    assert(cn.get(0) == 1ULL);
+    assert(cn.get(1) == 1ULL);
+    assert(cn.get(2) == 2ULL);
+    assert(cn.get(3) == 5ULL);
+    assert(cn.get(4) == 14ULL);
+    assert(cn.get(5) == 42ULL);
+    assert(cn.get(6) == 132ULL);
+    assert(cn.get(7) == 429ULL);
+    assert(cn.get(8) == 1430ULL);
+    assert(cn.get(9) == 4862ULL);
+    assert(cn.get(10) == 16796ULL);
+    assert(cn.get(11) == 58786ULL);
+    assert(cn.get(12) == 208012ULL);
+    assert(cn.get(13) == 742900ULL);
+    assert(cn.get(14) == 2674440ULL);
+    assert(cn.get(15) == 9694845ULL);
+    assert(cn.get(16) == 35357670ULL);
+    assert(cn.get(17) == 129644790ULL);
+    assert(cn.get(18) == 477638700ULL);
+    assert(cn.get(19) == 1767263190ULL);
+    assert(cn.get(20) == 6564120420ULL);
 }
 
-/** Sample Test Case:
-
-$ cd "Dynamic Programming"
-$ g++ Catalan-Numbers.cpp
-$ ./a.exe
-
-Enter n: 5
-Catalan numbers from 0 to 5 are:
-catalan (0) = 1
-catalan (1) = 1
-catalan (2) = 2
-catalan (3) = 5
-catalan (4) = 14
-catalan (5) = 42
+void test_catalan_numbers_25() {
+    // data verified with https://oeis.org/A000108/
+    catalan_numbers cn;
+    assert(cn.get(25) == 4861946401452ULL);
+}
 
-*/
+int main() {
+    test_catalan_numbers_up_to_20();
+    test_catalan_numbers_25();
+}