solved on 19/12/23

Author: Priyanshu-Ganatra

CS_39_NstacksInAnArray.cpp

@@ -0,0 +1,99 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class NStack
+{
+    int *arr;
+    int *top;
+    int *next;    // To store next entry in all stacks (the index of below the top element in the main array of stack m - useful for pop operation) and free list
+    int n;        // Number of stacks
+    int size;     // Size of main array
+    int freeSpot; // Index of free spot in main array
+public:
+    // constructor
+    NStack(int N, int S) : n(N), size(S)
+    {
+        freeSpot = 0;         // Initially all spaces are free
+        arr = new int[size];  // Main array of size S
+        top = new int[n];     // Stores top element of each stack in the main array thus same size as number of stacks
+        next = new int[size]; // Stores next entry in all stacks and free list thus same size as main array
+
+        // Initialize all stacks as empty
+        for (int i = 0; i < n; i++)
+        {
+            top[i] = -1;
+        }
+
+        // Initialize all spaces as free
+        for (int i = 0; i < size - 1; i++)
+        {
+            next[i] = i + 1;
+        }
+        next[size - 1] = -1; // -1 is used to indicate end of free list, setting last element of next[] as -1 as it itself is the last free spot
+    }
+
+    // destructor
+    ~NStack()
+    {
+        delete[] arr;
+        delete[] top;
+        delete[] next;
+    }
+
+    // Pushes 'X' into the Mth stack. Returns true if it gets pushed into the stack, and false otherwise.
+    // tc: O(1) sc: O(1)
+    bool push(int x, int m)
+    {
+        if (freeSpot == -1)
+        {
+            cout << "Stack overflow";
+            cout << ". Can't push " << x << " into stack " << m << endl;
+            return false; // No free spot left in main array thus stack overflow
+        }
+
+        int i = freeSpot;     // 1. Store index of free spot
+        freeSpot = next[i];   // 2. Update index of free spot to next free spot
+        arr[i] = x;           // 3. Put data in free spot
+        next[i] = top[m - 1]; // 4. Update next of free spot to index of top element of stack m, m-1 because m is 1-indexed
+        top[m - 1] = i;       // 5. Update top of stack m to index of free spot, m-1 because m is 1-indexed
+        cout << "Pushed " << x << " into stack " << m << endl;
+        return true; // 6. Return true as data is pushed into stack
+    }
+
+    // Pops top element from Mth Stack. Returns -1 if the stack is empty, otherwise returns the popped element.
+    // tc: O(1) sc: O(1)
+    int pop(int m)
+    {
+        if (top[m - 1] == -1)
+        {
+            cout << "Stack underflow";
+            cout << ". Can't pop from stack " << m << endl;
+            return -1; // Stack is empty thus stack underflow
+        }
+
+        // reverse process of push
+        int i = top[m - 1];   // 1. Store index of top element of stack m
+        top[m - 1] = next[i]; // 2. Update top of stack m to index of next element of top element of stack m (the element below the top element in the main array of stack m)
+        int popped = arr[i];  // 3. Store popped element
+        next[i] = freeSpot;   // 4. Update next of popped element to index of free spot
+        freeSpot = i;         // 5. Update index of free spot to index of popped element
+        cout << "Popped " << popped << " from stack " << m << endl;
+        return popped; // 6. Return popped element
+    }
+};
+
+int main()
+{
+    int n = 3, size = 6;
+    cout << "Number of stacks: " << n << endl;
+    cout << "Size of main array: " << size << endl << endl;
+    NStack stack(n, size);
+    stack.push(100, 1);
+    stack.push(200, 1);
+    stack.push(2000, 2);
+    stack.push(8, 3);
+    stack.push(4, 3);
+    stack.push(2, 3);
+    stack.push(3000, 2);
+    stack.push(1, 3);
+}

CS_40_NQueuesInAnArray.cpp

@@ -0,0 +1,104 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class NQueue
+{
+public:
+    int n, k, freeSpot; // n is size of main array, k is number of queues, freeSpot is index of free spot in main array
+    int *arr, *front, *rear, *next;
+    // constructor
+    NQueue(int n, int s) : n(s), k(n), freeSpot(0)
+    {
+        arr = new int[n];
+        next = new int[n];
+        front = new int[k];
+        rear = new int[k];
+
+        // Initialize all queues as empty
+        for (int i = 0; i < k; i++)
+        {
+            front[i] = rear[i] = -1;
+        }
+        // intialize all spaces as free
+        for (int i = 0; i < n; i++)
+        {
+            next[i] = i + 1;
+        }
+        next[n - 1] = -1; // -1 is used to indicate end of free list, setting last element of next[] as -1 as it itself is the last free spot
+    }
+
+    // destructor
+    ~NQueue()
+    {
+        delete[] arr;
+        delete[] front;
+        delete[] rear;
+        delete[] next;
+    }
+
+    // Enqueues 'X' into the Mth queue. Returns true if it gets pushed into the queue, and false otherwise.
+    bool enqueue(int x, int m)
+    {
+        // overflow check
+        if (freeSpot == -1)
+        {
+            cout << "Queue overflow";
+            cout << ". Can't enqueue " << x << " into queue " << m << endl;
+            return false; // No free spot left in main array thus queue overflow
+        }
+
+        int i = freeSpot;   // 1. Store index of free spot
+        freeSpot = next[i]; // 2. Update index of free spot to next free spot
+        // if first element is being enqueued
+        if (front[m - 1] == -1)
+        {
+            front[m - 1] = i; // 3. Update front of queue m to index of free spot, m-1 because m is 1-indexed
+        }
+        else    
+        {
+            // link the previous rear to the new rear (some elements may be in between which belong to other queues)
+            next[rear[m - 1]] = i; // 3. Update next of rear of queue m to index of free spot, m-1 because m is 1-indexed
+        }
+        next[i] = -1;    // 4. Update next of free spot to -1 to indicate end of queue 
+        rear[m - 1] = i; // 5. Update rear of queue m to index of free spot, m-1 because m is 1-indexed
+        arr[i] = x;      // 6. Put data in free spot
+        cout << "Enqueued " << x << " into queue " << m << endl;
+        return true; // 7. Return true as data is enqueued into queue
+    }
+
+    // Dequeues top element from Mth queue. Returns -1 if the queue is empty, otherwise returns the popped element.
+    int dequeue(int m)
+    {
+        // underflow check
+        if (front[m - 1] == -1)
+        {
+            cout << "Queue underflow";
+            cout << ". Can't dequeue from queue " << m << endl;
+            return -1; // Queue is empty thus queue underflow
+        }
+
+        // find index of front element of queue m to pop it
+        int i = front[m - 1];   // 1. Store index of front element of queue m
+        front[m - 1] = next[i]; // 2. Update front
+        // update free spots
+        next[i] = freeSpot; // 3. Update next of popped element to index of free spot
+        freeSpot = i;       // 4. Update index of free spot to index of popped element
+        cout << "Dequeued " << arr[i] << " from queue " << m << endl;
+        return arr[i]; // 5. Return popped element
+    }
+};
+
+int main()
+{
+    int n = 3, size = 6;
+    cout << "Number of queues: " << n << endl;
+    cout << "Size of main array: " << size << endl << endl;
+    NQueue q(n, size);
+    q.enqueue(1, 1);
+    q.enqueue(2, 1);
+    q.enqueue(3, 2);
+    q.enqueue(4, 2);
+    q.enqueue(5, 3);
+    q.enqueue(6, 3);
+    return 0;
+}