Merge branch 'master' into various_improvements

Panquesito7 · web-flow · commit 05dab77e9e1c · 2020-06-24T19:42:56.000-05:00
diff --git a/data_structures/stack.h b/data_structures/stack.h
@@ -1,26 +1,35 @@
-/* This class specifies the basic operation on a stack as a linked list */
+/**
+ * @file stack.h
+ * @author danghai
+ * @brief  This class specifies the basic operation on a stack as a linked list
+ **/
 #ifndef DATA_STRUCTURES_STACK_H_
 #define DATA_STRUCTURES_STACK_H_
 
 #include <cassert>
 #include <iostream>
 
-/* Definition of the node */
+/** Definition of the node as a linked-list
+ * \tparam Type type of data nodes of the linked list should contain
+ */
 template <class Type>
 struct node {
-    Type data;
-    node<Type> *next;
+    Type data;         ///< data at current node
+    node<Type> *next;  ///< pointer to the next ::node instance
 };
 
-/* Definition of the stack class */
+/** Definition of the stack class
+ * \tparam Type type of data nodes of the linked list in the stack should
+ * contain
+ */
 template <class Type>
 class stack {
  public:
     /** Show stack */
     void display() {
         node<Type> *current = stackTop;
         std::cout << "Top --> ";
-        while (current != NULL) {
+        while (current != nullptr) {
             std::cout << current->data << "  ";
             current = current->next;
         }
@@ -30,15 +39,45 @@ class stack {
 
     /** Default constructor*/
     stack() {
-        stackTop = NULL;
+        stackTop = nullptr;
         size = 0;
     }
 
+    /** Copy constructor*/
+    explicit stack(const stack<Type> &otherStack) {
+        node<Type> *newNode, *current, *last;
+
+        /* If stack is no empty, make it empty */
+        if (stackTop != nullptr) {
+            stackTop = nullptr;
+        }
+        if (otherStack.stackTop == nullptr) {
+            stackTop = nullptr;
+        } else {
+            current = otherStack.stackTop;
+            stackTop = new node<Type>;
+            stackTop->data = current->data;
+            stackTop->next = nullptr;
+            last = stackTop;
+            current = current->next;
+            /* Copy the remaining stack */
+            while (current != nullptr) {
+                newNode = new node<Type>;
+                newNode->data = current->data;
+                newNode->next = nullptr;
+                last->next = newNode;
+                last = newNode;
+                current = current->next;
+            }
+        }
+        size = otherStack.size;
+    }
+
     /** Destructor */
     ~stack() {}
 
     /** Determine whether the stack is empty */
-    bool isEmptyStack() { return (stackTop == NULL); }
+    bool isEmptyStack() { return (stackTop == nullptr); }
 
     /** Add new item to the stack */
     void push(Type item) {
@@ -52,7 +91,7 @@ class stack {
 
     /** Return the top element of the stack */
     Type top() {
-        assert(stackTop != NULL);
+        assert(stackTop != nullptr);
         return stackTop->data;
     }
 
@@ -70,30 +109,30 @@ class stack {
     }
 
     /** Clear stack */
-    void clear() { stackTop = NULL; }
+    void clear() { stackTop = nullptr; }
 
     /** Overload "=" the assignment operator */
     stack<Type> &operator=(const stack<Type> &otherStack) {
         node<Type> *newNode, *current, *last;
 
         /* If stack is no empty, make it empty */
-        if (stackTop != NULL) {
-            stackTop = NULL;
+        if (stackTop != nullptr) {
+            stackTop = nullptr;
         }
-        if (otherStack.stackTop == NULL) {
-            stackTop = NULL;
+        if (otherStack.stackTop == nullptr) {
+            stackTop = nullptr;
         } else {
             current = otherStack.stackTop;
             stackTop = new node<Type>;
             stackTop->data = current->data;
-            stackTop->next = NULL;
+            stackTop->next = nullptr;
             last = stackTop;
             current = current->next;
             /* Copy the remaining stack */
-            while (current != NULL) {
+            while (current != nullptr) {
                 newNode = new node<Type>;
                 newNode->data = current->data;
-                newNode->next = NULL;
+                newNode->next = nullptr;
                 last->next = newNode;
                 last = newNode;
                 current = current->next;
@@ -105,7 +144,7 @@ class stack {
 
  private:
     node<Type> *stackTop; /**< Pointer to the stack */
-    int size;
+    int size;             ///< size of stack
 };
 
 #endif  // DATA_STRUCTURES_STACK_H_
diff --git a/data_structures/stack_using_array.cpp b/data_structures/stack_using_array.cpp
@@ -1,37 +1,38 @@
 #include <iostream>
 
 int *stack;
-int top = 0, stack_size;
+int stack_idx = 0, stack_size;
 
 void push(int x) {
-    if (top == stack_size) {
+    if (stack_idx == stack_size) {
         std::cout << "\nOverflow";
     } else {
-        stack[top++] = x;
+        stack[stack_idx++] = x;
     }
 }
 
 void pop() {
-    if (top == 0) {
+    if (stack_idx == 0) {
         std::cout << "\nUnderflow";
     } else {
-        std::cout << "\n" << stack[--top] << " deleted";
+        std::cout << "\n" << stack[--stack_idx] << " deleted";
     }
 }
 
 void show() {
-    for (int i = 0; i < top; i++) {
+    for (int i = 0; i < stack_idx; i++) {
         std::cout << stack[i] << "\n";
     }
 }
 
-void topmost() { std::cout << "\nTopmost element: " << stack[top - 1]; }
+void topmost() { std::cout << "\nTopmost element: " << stack[stack_idx - 1]; }
 int main() {
     std::cout << "\nEnter stack_size of stack : ";
     std::cin >> stack_size;
     stack = new int[stack_size];
     int ch, x;
     do {
+        std::cout << "\n0. Exit";
         std::cout << "\n1. Push";
         std::cout << "\n2. Pop";
         std::cout << "\n3. Print";
@@ -51,5 +52,7 @@ int main() {
         }
     } while (ch != 0);
 
+    delete[] stack;
+
     return 0;
 }
diff --git a/data_structures/stack_using_linked_list.cpp b/data_structures/stack_using_linked_list.cpp
@@ -5,28 +5,28 @@ struct node {
     node *next;
 };
 
-node *top;
+node *top_var;
 
 void push(int x) {
     node *n = new node;
     n->val = x;
-    n->next = top;
-    top = n;
+    n->next = top_var;
+    top_var = n;
 }
 
 void pop() {
-    if (top == nullptr) {
+    if (top_var == nullptr) {
         std::cout << "\nUnderflow";
     } else {
-        node *t = top;
+        node *t = top_var;
         std::cout << "\n" << t->val << " deleted";
-        top = top->next;
+        top_var = top_var->next;
         delete t;
     }
 }
 
 void show() {
-    node *t = top;
+    node *t = top_var;
     while (t != nullptr) {
         std::cout << t->val << "\n";
         t = t->next;
diff --git a/math/fibonacci_fast.cpp b/math/fibonacci_fast.cpp
@@ -19,28 +19,32 @@
 #include <cstdio>
 #include <iostream>
 
-/** maximum number that can be computed - The result after 93 cannot be stored
- * in a `uint64_t` data type. */
-const uint64_t MAX = 93;
+/**
+ * maximum number that can be computed - The result after 93 cannot be stored
+ * in a `uint64_t` data type.
+ */
 
-/** Array of computed fibonacci numbers */
-uint64_t f[MAX] = {0};
+#define MAX 93
 
 /** Algorithm */
 uint64_t fib(uint64_t n) {
-    if (n == 0)
+    static uint64_t f1 = 1,
+                    f2 = 1;  // using static keyword will retain the values of
+                             // f1 and f2 for the next function call.
+
+    if (n <= 2)
+        return f2;
+    if (n >= 93) {
+        std::cerr
+            << "Cannot compute for n>93 due to limit of 64-bit integers\n";
         return 0;
-    if (n == 1 || n == 2)
-        return (f[n] = 1);
-
-    if (f[n])
-        return f[n];
+    }
 
-    uint64_t k = (n % 2 != 0) ? (n + 1) / 2 : n / 2;
+    uint64_t temp = f2;  // we do not need temp to be static
+    f2 += f1;
+    f1 = temp;
 
-    f[n] = (n % 2 != 0) ? (fib(k) * fib(k) + fib(k - 1) * fib(k - 1))
-                        : (2 * fib(k - 1) + fib(k)) * fib(k);
-    return f[n];
+    return f2;
 }
 
 /** Main function */
diff --git a/others/matrix_exponentiation.cpp b/others/matrix_exponentiation.cpp
@@ -39,18 +39,15 @@ using std::vector;
 #define pb push_back
 #define MOD 1000000007
 
-/** returns absolute value */
-inline ll ab(ll x) { return x > 0LL ? x : -x; }
-
-/** global variable k
+/** global variable mat_size
  * @todo @stepfencurryxiao add documetnation
  */
-ll k;
+ll mat_size;
 
-/** global vector variables
+/** global vector variables used in the ::ans function.
  * @todo @stepfencurryxiao add documetnation
  */
-vector<ll> a, b, c;
+vector<ll> fib_b, fib_c;
 
 /** To multiply 2 matrices
  * \param [in] A matrix 1 of size (m\f$\times\f$n)
@@ -59,10 +56,10 @@ vector<ll> a, b, c;
  */
 vector<vector<ll>> multiply(const vector<vector<ll>> &A,
                             const vector<vector<ll>> &B) {
-    vector<vector<ll>> C(k + 1, vector<ll>(k + 1));
-    for (ll i = 1; i <= k; i++) {
-        for (ll j = 1; j <= k; j++) {
-            for (ll z = 1; z <= k; z++) {
+    vector<vector<ll>> C(mat_size + 1, vector<ll>(mat_size + 1));
+    for (ll i = 1; i <= mat_size; i++) {
+        for (ll j = 1; j <= mat_size; j++) {
+            for (ll z = 1; z <= mat_size; z++) {
                 C[i][j] = (C[i][j] + (A[i][z] * B[z][j]) % MOD) % MOD;
             }
         }
@@ -94,32 +91,32 @@ vector<vector<ll>> power(const vector<vector<ll>> &A, ll p) {
 ll ans(ll n) {
     if (n == 0)
         return 0;
-    if (n <= k)
-        return b[n - 1];
+    if (n <= mat_size)
+        return fib_b[n - 1];
     // F1
-    vector<ll> F1(k + 1);
-    for (ll i = 1; i <= k; i++) F1[i] = b[i - 1];
+    vector<ll> F1(mat_size + 1);
+    for (ll i = 1; i <= mat_size; i++) F1[i] = fib_b[i - 1];
 
     // Transpose matrix
-    vector<vector<ll>> T(k + 1, vector<ll>(k + 1));
-    for (ll i = 1; i <= k; i++) {
-        for (ll j = 1; j <= k; j++) {
-            if (i < k) {
+    vector<vector<ll>> T(mat_size + 1, vector<ll>(mat_size + 1));
+    for (ll i = 1; i <= mat_size; i++) {
+        for (ll j = 1; j <= mat_size; j++) {
+            if (i < mat_size) {
                 if (j == i + 1)
                     T[i][j] = 1;
                 else
                     T[i][j] = 0;
                 continue;
             }
-            T[i][j] = c[k - j];
+            T[i][j] = fib_c[mat_size - j];
         }
     }
     // T^n-1
     T = power(T, n - 1);
 
     // T*F1
     ll res = 0;
-    for (ll i = 1; i <= k; i++) {
+    for (ll i = 1; i <= mat_size; i++) {
         res = (res + (T[1][i] * F1[i]) % MOD) % MOD;
     }
     return res;
@@ -133,19 +130,19 @@ int main() {
     cin >> t;
     ll i, j, x;
     while (t--) {
-        cin >> k;
-        for (i = 0; i < k; i++) {
+        cin >> mat_size;
+        for (i = 0; i < mat_size; i++) {
             cin >> x;
-            b.pb(x);
+            fib_b.pb(x);
         }
-        for (i = 0; i < k; i++) {
+        for (i = 0; i < mat_size; i++) {
             cin >> x;
-            c.pb(x);
+            fib_c.pb(x);
         }
         cin >> x;
         cout << ans(x) << endl;
-        b.clear();
-        c.clear();
+        fib_b.clear();
+        fib_c.clear();
     }
     return 0;
 }
diff --git a/others/paranthesis_matching.cpp b/others/paranthesis_matching.cpp
diff --git a/sorting/heap_sort.cpp b/sorting/heap_sort.cpp
