solved in 15/12/23

Author: Priyanshu-Ganatra

LC_102_SlidingWindowMaximum.cpp

@@ -0,0 +1,32 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// tc : O(n) sc : O(n)
+vector<int> maxSlidingWindow(vector<int> &nums, int k)
+{
+    vector<int> ans;    
+    deque<int> q; // store the index of the maximum elements in the window  
+    // process first k elements - 1st window
+    for (int i = 0; i < k; i++)
+    {
+        // remove the elements which are smaller than the current element because they can't be the maximum element in the window
+        while (!q.empty() && nums[i] >= nums[q.back()]) 
+            q.pop_back();
+        q.push_back(i); // add the current element as it can be the maximum element in the window and the next window
+    }
+    // process remaining windows -> remove the element which is out of the window and add the new the element
+    for (int i = k; i < nums.size(); i++)
+    {
+        ans.push_back(nums[q.front()]); // add the maximum element of the previous window in the answer array
+        // remove the front element if it is out of the window
+        if (i - q.front() >= k)
+            q.pop_front();
+        // remove the elements which are smaller than the current element because they can't be the maximum element in the window
+        while (!q.empty() && nums[i] >= nums[q.back()]) 
+            q.pop_back();
+        q.push_back(i); // add the current element as it can be the maximum element in the window and the next window
+    }
+    // process the last window
+    ans.push_back(nums[q.front()]);
+    return ans;
+}

LC_103_DesignCircularQueue.cpp

@@ -0,0 +1,106 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// Time Complexity: O(1)
+// Space Complexity: O(N)
+class MyCircularQueue
+{
+public:
+    MyCircularQueue(int k)
+    {
+        // the queue holding the elements for the circular queue
+        q.resize(k);
+        // the number of elements in the circular queue
+        cnt = 0;
+        // queue size
+        sz = k;
+        // the idx of the head element
+        headIdx = 0;
+    }
+
+    bool enQueue(int value)
+    {
+        // handle full case
+        if (isFull())
+            return false;
+        // Given an array of size of 4, we can find the position to be inserted using the formula
+        // targetIdx = (headIdx + cnt) % sz
+        // e.g. [1, 2, 3, _]
+        // headIdx = 0, cnt = 3, sz = 4, targetIdx = (0 + 3) % 4 = 3
+        // e.g. [_, 2, 3, 4]
+        // headIdx = 1, cnt = 3, sz = 4, targetIdx = (1 + 3) % 4 = 0
+        q[(headIdx + cnt) % sz] = value;
+        // increase the number of elements by 1
+        cnt += 1;
+        return true;
+    }
+
+    bool deQueue()
+    {
+        // handle empty case
+        if (isEmpty())
+            return false;
+        // update the head index
+        headIdx = (headIdx + 1) % sz;
+        // decrease the number of elements by 1
+        cnt -= 1;
+        return true;
+    }
+
+    int Front()
+    {
+        // handle empty queue case
+        if (isEmpty())
+            return -1;
+        // return the head element
+        return q[headIdx];
+    }
+
+    int Rear()
+    {
+        // handle empty queue case
+        if (isEmpty())
+            return -1;
+        // Given an array of size of 4, we can find the tailIdx using the formula
+        // tailIdx = (headIdx + cnt - 1) % sz
+        // e.g. [0 1 2] 3
+        // headIdx = 0, cnt = 3, sz = 4, tailIdx = (0 + 3 - 1) % 4 = 2
+        // e.g. 0 [1 2 3]
+        // headIdx = 1, cnt = 3, sz = 4, tailIdx = (1 + 3 - 1) % 4 = 3
+        // e.g. 0] 1 [2 3
+        // headIdx = 2, cnt = 3, sz = 4, tailIdx = (2 + 3 - 1) % 4 = 0
+        return q[(headIdx + cnt - 1) % sz];
+    }
+
+    bool isEmpty()
+    {
+        // no element in the queue
+        return cnt == 0;
+    }
+
+    bool isFull()
+    {
+        // return true if the count is equal to the queue size
+        // else return false
+        return cnt == sz;
+    }
+
+private:
+    int cnt, sz, headIdx;
+    vector<int> q;
+};
+
+int main()
+{
+    MyCircularQueue *obj = new MyCircularQueue(3);
+    cout << obj->enQueue(1) << endl;
+    cout << obj->enQueue(2) << endl;
+    cout << obj->enQueue(3) << endl;
+    cout << obj->enQueue(4) << endl;
+    cout << obj->Rear() << endl;
+    cout << obj->isFull() << endl;
+    cout << obj->deQueue() << endl;
+    cout << obj->enQueue(4) << endl;
+    cout << obj->Rear() << endl;
+    return 0;
+}

LC_104_DesignCircularDeque.cpp

@@ -0,0 +1,153 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class MyCircularDeque
+{
+    int size, front, rear, *arr;
+
+public:
+    MyCircularDeque(int k)
+    {
+        size = k;
+        front = rear = -1;
+        arr = new int[size];
+    }
+
+    ~MyCircularDeque()
+    {
+        delete[] arr;
+    }
+
+    bool insertFront(int value)
+    {
+        if (isFull())
+            return false;
+        else if (isEmpty())
+        {
+            front++;
+            rear++;
+            arr[front] = value;
+        }
+        else if (front == 0 && rear != size - 1)
+        { // circular nature
+            front = size - 1;
+            arr[front] = value;
+        }
+        else
+        {
+            front--;
+            arr[front] = value;
+        }
+        return true;
+    }
+
+    bool insertLast(int value)
+    {
+        if (isFull())
+            return false;
+        else if (isEmpty())
+        {
+            front++;
+            rear++;
+            arr[rear] = value;
+        }
+        else if (rear == size - 1 && front != 0)
+        { // circular nature
+            rear = 0;
+            arr[rear] = value;
+        }
+        else
+        {
+            arr[++rear] = value;
+        }
+        return true;
+    }
+
+    bool deleteFront()
+    {
+        if (isEmpty())
+            return false;
+        else if (front == rear)
+        { // single element
+            arr[front] = -1;
+            front = rear = -1;
+        }
+        else if (front == size - 1)
+        { // circular nature
+            arr[front] = -1;
+            front = 0;
+        }
+        else
+        {
+            arr[front] = -1;
+            front++;
+        }
+        return true;
+    }
+
+    bool deleteLast()
+    {
+        if (isEmpty())
+            return false;
+        else if (front == rear)
+        { // single element
+            arr[rear] = -1;
+            front = rear = -1;
+        }
+        else if (rear == 0)
+        { // circular nature
+            rear = size - 1;
+        }
+        else
+        {
+            arr[rear] = -1;
+            rear--;
+        }
+        return true;
+    }
+
+    int getFront()
+    {
+        if (isEmpty())
+            return -1;
+        else
+        {
+            return arr[front];
+        }
+    }
+
+    int getRear()
+    {
+        if (isEmpty())
+            return -1;
+        else
+        {
+            return arr[rear];
+        }
+    }
+
+    bool isEmpty()
+    {
+        return (front == -1 && rear == -1);
+    }
+
+    bool isFull()
+    {
+        return (front == 0 && rear == size - 1) || (rear == front - 1);
+    }
+};
+
+int main()
+{
+    MyCircularDeque *obj = new MyCircularDeque(3);
+    cout << obj->insertFront(1) << endl;
+    cout << obj->insertLast(2) << endl;
+    cout << obj->insertFront(3) << endl;
+    cout << obj->insertLast(4) << endl;
+    cout << obj->getRear() << endl;
+    cout << obj->isFull() << endl;
+    cout << obj->deleteLast() << endl;
+    cout << obj->insertFront(4) << endl;
+    cout << obj->getFront() << endl;
+    return 0;
+}