Stack queue in cpp

contents/stacks_and_queues/code/c++/queue.cpp

@@ -0,0 +1,100 @@
+#include<iostream>
+using namespace std;
+
+namespace my {
+    /**
+     * parameterised type implementation using linked list
+     * [value][next] -> [value][next] -> ... -> [value][next] -> [value][next]
+     *  (front Node)   (intermediat Nodes)    (rear Node)      (dummy Node)
+     */
+    template<typename T>
+    struct Node {
+        /**
+        * next: will store right Node address
+        */
+        T value;
+        Node<T>* next;
+        Node(const T& V) : value(V), next(nullptr) { }
+    };
+
+    template<typename T>
+    class queue {
+    private:
+        /**
+         * _front :  points to left most node
+         * count: keeps track of current number of elements present in queue excluding dummy Node
+         * rear:  points to most recent Node added into the queue, which is just left size of dummy Node
+         */
+        Node<T>* _front;
+        Node<T>* rear;
+        size_t count;
+    public:
+        queue() : _front(nullptr), rear(nullptr), count(0ULL) {
+            _front = rear = new Node<T>(0); // creating a dummy Node
+        }
+
+        void push(const T& element) {
+            Node<T>* new_node = new Node<T>(element);  // create New Node
+            if (count > 0) {
+                new_node->next = rear->next; // make new Node point to dummy Node
+                rear->next = new_node;       // make rear Node point to new Node
+                rear = new_node;             // make rear Node's pointer to point to new Node
+            } else {
+                new_node->next = rear;
+                rear = _front = new_node;
+            }
+            count = count + 1;
+        }
+
+        void dequeue() {
+            if (count > 0) {
+                Node<T>* buffer = _front;
+                _front = _front->next;
+                count = count - 1;
+                delete buffer;
+            }
+            rear = (count != 0) ? rear : _front;
+        }
+
+        T& front() const { return _front->value; }
+        // returning reference can very usefull if someone wants to modify _front element
+
+        size_t size() const { return count; }
+
+        bool empty() const { return count == 0; }
+
+        ~queue() {
+            for (Node<T>* pointer = _front; pointer != nullptr;) {
+                Node<T>* buffer = pointer;
+                pointer = pointer->next;
+                delete buffer;
+            }
+        }
+    };
+}
+
+int main() {
+    my::queue<int> Q;
+
+    Q.push(0);
+    Q.push(1);
+    Q.push(2);
+    Q.push(3);
+    cout << "count: " << Q.size() << endl;
+    Q.front() = 10;
+
+    while (Q.empty() != true) {
+        cout << "element: " << Q.front() << endl;
+        Q.dequeue();
+    }
+
+    Q.push(3);
+    Q.push(6);
+    cout << "count: " << Q.size() << endl;
+    while (Q.empty() != true) {
+        cout << "element: " << Q.front() << endl;
+        Q.dequeue();
+    }
+    return 0;
+}
+

contents/stacks_and_queues/code/c++/stack.cpp

@@ -0,0 +1,80 @@
+#include<iostream>
+using namespace std;
+
+namespace my {
+    /**
+     *implementation using parameterised linked list
+     * [value][next] -> [value][next] -> ... -> [value][next]
+     * (top Node)      (intermediat Nodes)      (dummy Node)
+     */
+    template<typename T>
+    struct Node {
+        /**
+        * next: will store right Node address
+        */
+        T value;
+        Node<T>* next;
+        Node(const T& V) : value(V), next(nullptr) { }
+    };
+
+    template<typename T>
+    class stack {
+    private:
+        /**
+         * _top:  points to left most node
+         * count: keeps track of current number of elements present in stack excluding dummy Node
+         */
+        Node<T>* _top;
+        size_t count;
+    public:
+        stack() : _top(nullptr), count(0ULL) {
+            _top = new Node<T>(0); // creating a dummy node
+        }
+
+        void push(const T& element) {
+            Node<T>* buffer = new Node<T>(element);
+            buffer->next = _top;
+            _top = buffer;
+            count = count + 1;
+        }
+
+        void pop() {
+            if (count > 0) {
+                Node<T>* buffer = _top;
+                _top = _top->next;
+                count = count - 1;
+                delete buffer;
+            }
+        }
+
+        T& top() const { return _top->value; }
+        // returning reference can very usefull if someone wants to modify top element
+
+        size_t size() const { return count; }
+
+        bool empty() const { return count == 0; }
+
+        ~stack() {
+            for (Node<T>* pointer = _top; pointer != nullptr;) {
+                Node<T>* buffer = pointer;
+                pointer = pointer->next;
+                delete buffer;
+            }
+        }
+    };
+}
+
+int main() {
+    my::stack<int> S;
+    S.push(0);
+    S.push(1);
+    S.push(2);
+    S.push(3);
+    cout << "size: " << S.size() << endl;
+    S.top() = 10;
+    while (S.empty() != true) {
+        cout << "element: " << S.top() << endl;
+        S.pop();
+    }
+    return 0;
+}

contents/stacks_and_queues/stacks_and_queues.md

@@ -20,6 +20,8 @@ Here is a simple implementation of a stack:
 [import, lang:"typescript"](code/typescript/stack.ts)
 {% sample lang="java" %}
 [import, lang:"java"](code/java/Stack.java)
+{% sample lang = "cpp"%}
+[import, lang:"cpp"](code/c++/stack.cpp)
 {% endmethod %}
 
 Here is a simple implementation of a queue:
@@ -28,6 +30,8 @@ Here is a simple implementation of a queue:
 [import, lang:"typescript"](code/typescript/queue.ts)
 {% sample lang="java" %}
 [import, lang:"java" ](code/java/Queue.java)
+{% sample lang = "cpp"%}
+[import, lang:"cpp"](code/c++/queue.cpp)
 {% endmethod %}