Merge branch 'master' into cstdint

Author: realstealthninja

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) {

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();
+}

greedy_algorithms/huffman.cpp

@@ -34,16 +34,15 @@ void deleteAll(const MinHeapNode* const root) {
 // For comparison of
 // two heap nodes (needed in min heap)
 struct compare {
-    bool operator()(MinHeapNode* l, MinHeapNode* r)
-
-    {
-        return (l->freq > r->freq);
+    bool operator()(const MinHeapNode* const l,
+                    const MinHeapNode* const r) const {
+        return l->freq > r->freq;
     }
 };
 
 // Prints huffman codes from
 // the root of Huffman Tree.
-void printCodes(struct MinHeapNode* root, string str) {
+void printCodes(struct MinHeapNode* root, const string& str) {
     if (!root)
         return;
 
@@ -56,8 +55,8 @@ void printCodes(struct MinHeapNode* root, string str) {
 
 // The main function that builds a Huffman Tree and
 // print codes by traversing the built Huffman Tree
-void HuffmanCodes(char data[], int freq[], int size) {
-    struct MinHeapNode *left, *right, *top;
+void HuffmanCodes(const char data[], const int freq[], int size) {
+    struct MinHeapNode *left, *right;
 
     // Create a min heap & inserts all characters of data[]
     priority_queue<MinHeapNode*, vector<MinHeapNode*>, compare> minHeap;
@@ -82,7 +81,7 @@ void HuffmanCodes(char data[], int freq[], int size) {
         // of this new node. Add this node
         // to the min heap '$' is a special value
         // for internal nodes, not used
-        top = new MinHeapNode('$', left->freq + right->freq);
+        auto* const top = new MinHeapNode('$', left->freq + right->freq);
 
         top->left = left;
         top->right = right;

search/median_search2.cpp

@@ -103,7 +103,7 @@ static void test() {
     }
     temp->next = nullptr;
 
-    ListNode* median = search::median_search2::middleNode(head1);
+    const ListNode* const median = search::median_search2::middleNode(head1);
     assert(3 == median->val);  // 3 is the value of the median node.
     search::median_search2::deleteAll(head1);
     std::cout << "test case:1 passed\n";
@@ -124,7 +124,7 @@ static void test() {
     }
     temp2->next = nullptr;
 
-    ListNode* median1 = search::median_search2::middleNode(head2);
+    const ListNode* const median1 = search::median_search2::middleNode(head2);
     assert(4 == median1->val);  // 4 is the value of the median node.
     search::median_search2::deleteAll(head2);
     std::cout << "test case:2 passed\n";