Add Double-Ended Queue (Deque) implementation in C++

CPP/algorithms/dynamic_programming/egg_dropping.cpp

@@ -0,0 +1,41 @@
+#include <iostream>
+#include <vector>
+#include <climits>
+using namespace std;
+
+// Function to find minimum number of attempts needed
+int eggDrop(int eggs, int floors) {
+    vector<vector<int>> dp(eggs + 1, vector<int>(floors + 1, 0));
+
+    // Base cases
+    for (int i = 1; i <= eggs; i++)
+        dp[i][0] = 0, dp[i][1] = 1;
+    for (int j = 1; j <= floors; j++)
+        dp[1][j] = j;
+
+    // Fill the rest using DP
+    for (int e = 2; e <= eggs; e++) {
+        for (int f = 2; f <= floors; f++) {
+            dp[e][f] = INT_MAX;
+            for (int k = 1; k <= f; k++) {
+                int attempts = 1 + max(dp[e - 1][k - 1], dp[e][f - k]);
+                dp[e][f] = min(dp[e][f], attempts);
+            }
+        }
+    }
+
+    return dp[eggs][floors];
+}
+
+int main() {
+    int eggs, floors;
+    cout << "Enter number of eggs: ";
+    cin >> eggs;
+    cout << "Enter number of floors: ";
+    cin >> floors;
+
+    int minAttempts = eggDrop(eggs, floors);
+    cout << "Minimum number of attempts needed: " << minAttempts << endl;
+
+    return 0;
+}

CPP/data_structures/queues/queue/deque.cpp

@@ -0,0 +1,123 @@
+#include <iostream>
+#include <stdexcept>
+
+template <typename T>
+class Deque {
+private:
+    struct Node {
+        T data;
+        Node* prev;
+        Node* next;
+    };
+
+    Node* front;
+    Node* rear;
+    int size;
+
+public:
+    Deque() : front(nullptr), rear(nullptr), size(0) {}
+
+    ~Deque() {
+        while (size > 0) {
+            deleteFront();
+        }
+    }
+
+    void insertFront(T value) {
+        Node* newNode = new Node{value, nullptr, front};
+        if (front) {
+            front->prev = newNode;
+        }
+        front = newNode;
+        if (!rear) {
+            rear = front;
+        }
+        ++size;
+    }
+
+    void insertRear(T value) {
+        Node* newNode = new Node{value, rear, nullptr};
+        if (rear) {
+            rear->next = newNode;
+        }
+        rear = newNode;
+        if (!front) {
+            front = rear;
+        }
+        ++size;
+    }
+
+    void deleteFront() {
+        if (front) {
+            Node* temp = front;
+            front = front->next;
+            if (front) {
+                front->prev = nullptr;
+            } else {
+                rear = nullptr;
+            }
+            delete temp;
+            --size;
+        } else {
+            throw std::out_of_range("Deque is empty");
+        }
+    }
+
+    void deleteRear() {
+        if (rear) {
+            Node* temp = rear;
+            rear = rear->prev;
+            if (rear) {
+                rear->next = nullptr;
+            } else {
+                front = nullptr;
+            }
+            delete temp;
+            --size;
+        } else {
+            throw std::out_of_range("Deque is empty");
+        }
+    }
+
+    T getFront() const {
+        if (front) {
+            return front->data;
+        } else {
+            throw std::out_of_range("Deque is empty");
+        }
+    }
+
+    T getRear() const {
+        if (rear) {
+            return rear->data;
+        } else {
+            throw std::out_of_range("Deque is empty");
+        }
+    }
+
+    int getSize() const {
+        return size;
+    }
+
+    bool isEmpty() const {
+        return size == 0;
+    }
+};
+
+int main() {
+    Deque<int> dq;
+    dq.insertFront(10);
+    dq.insertRear(20);
+    dq.insertFront(5);
+
+    std::cout << "Front: " << dq.getFront() << std::endl;
+    std::cout << "Rear: " << dq.getRear() << std::endl;
+    std::cout << "Size: " << dq.getSize() << std::endl;
+
+    dq.deleteFront();
+    dq.deleteRear();
+
+    std::cout << "Size after deletions: " << dq.getSize() << std::endl;
+
+    return 0;
+}