Added C++ Data Structures

dijorajsenroy · web-flow · commit c4503c379db3 · 2021-04-25T20:13:42.000+05:30
diff --git a/Cpp/LinkedList.cpp b/Cpp/LinkedList.cpp
@@ -0,0 +1,182 @@
+// Implementation of a Linked List in C++
+#include <iostream>
+using namespace std;
+
+// Implementation of a Node
+class Node{
+    public:
+        Node *next; // Node pointer to point to next node
+        int data; // Integer stored in each node
+    public:
+        Node(int x){
+            data = x; // storing the data
+            next = NULL; // pointer to next node is null by default
+        }
+};
+// Implementation of a Linked List Class
+class SingleLinkedList{
+    private:
+    int listsize; // variable to store size of list
+    Node *head; // Node pointer to point to head node
+    public:
+    // constructor to initialise the list
+    SingleLinkedList(){
+        head = NULL;
+        listsize = 0;
+    }
+    // Function to insert an element at the start
+    void insertionAtHead(int data){
+        Node *new_node = new Node(data); // create a new node
+        // if the list is empty new node is head node
+        if(head == NULL){
+            head = new_node;
+        }
+        else{
+            // link the new node to head
+            new_node->next = head;
+            head = new_node;
+        }
+        listsize++;
+    }
+    // Function to insert an element at the end
+    void insertionAtTail(int data){
+        Node *new_node = new Node(data); // Create a new node
+        // if the list is empty new node is head node
+        if (head == NULL){
+            head = new_node;
+        }
+        else{
+            // link the last node of the linked list to the new node
+            Node *curr = head; //current pointer to head node
+            while(curr->next != NULL){
+                // traverse till last node is reached
+                curr = curr->next;
+            }
+            curr->next = new_node;
+            listsize++;
+        }
+    }
+    // Function to insert at a user specified position
+    void insertionAtPos(int pos, int data){
+        if (pos < 0 && pos > listsize + 1){
+            // check is pos is a valid position in the list
+            cout << pos << " does not exist in the list" << endl;
+        }
+        else{
+            if (pos == 0){
+                // insert at head
+                insertionAtHead(data);
+            }
+            else if (pos == listsize + 1){
+                //insertion at tail
+                insertionAtTail(data);
+            }
+            else{
+                // insert anywhere else
+                Node *new_node = new Node(data); // new node
+                Node *curr = head; // pointer to the head node
+                Node *prev = head; //pointer to store previous node
+                int count = 0; //count positions till pos
+                while(curr != NULL){
+                    if(count == pos){break;}
+                    count++;
+                    prev = curr;
+                    curr = curr->next;
+                }
+                // insertion between prev and curr if pos is found
+                if (curr != NULL)
+                {
+                    prev->next = new_node;
+                    new_node->next = curr;
+                }
+            }
+            listsize++;
+        }
+    }
+    //Function to delete head node of a linked list
+    void deletionAtHead(){
+        if(head == NULL){
+            cout << "List is empty"<< endl;
+        }
+        else{
+            cout << head->data << " has been deleted" << endl;
+            Node *after = head->next; //pointer to point to next of head node
+            head->next = NULL; //de-link head node from the rest of the list
+            head = after; //set next node as the head node, or NULL
+            listsize--;
+        }   
+    }
+    // Function to delete the tail node of a linked list
+    void deletionAtTail(){
+        if (head == NULL){
+            cout << "List is empty" << endl;
+        }
+        else{
+            //traverse to the last node
+            Node *curr = head; // pointer to the head node
+            Node *prev; //pointer to the second last node after traversal
+            while(curr->next != NULL){
+                //traverses till last node
+                prev = curr;
+                curr = curr->next;
+            }
+            //deletion of curr
+            cout << curr->data << " has been deleted" << endl;
+            prev->next = NULL;
+            listsize--;
+        }
+    }
+    //Function to delete key specified by user
+    void deleteKey(int key){
+        if (head == NULL){
+            cout << "List is empty" << endl;
+        }
+        else{
+            //if key is at head
+            if(head->data == key){deletionAtHead();}
+            else{
+                //traverse to the last node
+                Node *curr = head; // pointer to the head node
+                Node *prev; //pointer to the second last node after traversal
+                while (curr != NULL){
+                    if(curr->data == key){break;}
+                    prev = curr;
+                    curr = curr->next;
+                }
+                if(curr != NULL){
+                    //deletion of curr
+                    cout << curr->data << " has been deleted" << endl;
+                    Node *temp = curr->next;
+                    curr->next = NULL;
+                    prev->next = temp;
+                }
+                else{
+                    cout << key << " does not exist" << endl;
+                }
+            }
+        }
+    }
+    // Function to display the linked list
+    void display(){
+        Node *curr = head;
+        while(curr != NULL){
+            cout << curr->data << "-->";
+            curr = curr->next;
+        }
+        cout << "Null" << endl;
+    }
+};
+
+int main(){
+    SingleLinkedList L;
+    L.insertionAtHead(1);
+    L.insertionAtTail(2);
+    L.insertionAtPos(3,3);
+    L.insertionAtTail(4);
+    L.display();
+    L.deletionAtHead();
+    L.deletionAtTail();
+    L.deleteKey(3);
+    L.display();
+    return 0;
+}
diff --git a/Cpp/QueueUsingArray.cpp b/Cpp/QueueUsingArray.cpp
@@ -0,0 +1,65 @@
+// Implementation of a Queue using Array 
+#include <iostream>
+using namespace std;
+
+class Queue{
+    public:
+    int front, rear, size;
+    int *arr; // the array used to implement the queue
+    int maxlen;
+    public:
+    Queue(int m){
+        maxlen = m;
+        arr = new int[m];
+        front = 0; // set to the first index of arr
+        rear = m - 1; // set to the last index of arr
+        size = 0;
+    }
+    // Insert into the Queue (EnQueue Operation)
+    void enqueue(int data){
+        // Check for overflow: Front reaches Rear
+        if(size == maxlen){
+            cout << "Queue Overflow Error" << endl; 
+        }
+        else{
+            rear = (rear + 1) % maxlen; // Incrementing Rear
+            // Item is added to the Rear of the Queue
+            arr[rear] = data;
+            size++;
+        }
+    }
+    // Display front element of the queue
+    void displayFront(){
+        cout << arr[front] << endl;
+    }
+    // Display rear element of the queue
+    void displayRear(){
+        cout << arr[rear] << endl;
+    }
+    // Delete an element from the Queue (DeQueue Operation)
+    void dequeue(){
+        // Check for underflow: Front exceeds Rear
+        if(size == 0){
+            cout << "Queue Underflow Error" << endl;
+        }
+        else{
+            // Item is removed from the Front of the Queue
+            cout << arr[front] << " was deleted" << endl;
+            front = (front + 1) % maxlen; // Incrementing Front
+            size--;
+        }
+    }
+};
+
+int main(){
+    Queue q(5);
+    q.enqueue(1);
+    q.enqueue(2);
+    q.displayFront();
+    q.displayRear();
+    q.dequeue();
+    q.enqueue(3);
+    q.displayFront();
+    q.displayRear();
+    return 0;
+}
diff --git a/Cpp/QueueUsingLL.cpp b/Cpp/QueueUsingLL.cpp
@@ -0,0 +1,84 @@
+// Implementation of Queue using Linked Lists
+
+#include <iostream>
+using namespace std;
+
+// Node class
+class Node{
+    public:
+    int data;
+    Node *next;
+    public:
+    Node(int x){
+        data = x;
+        next = NULL;
+    }
+};
+
+// Implementing Queue
+class Queue{
+    public:
+    int size, maxlen; // size and max length of the queue
+    Node *front, *rear; // Node pointers to point to front and rear nodes
+    public:
+    Queue(int m){
+        // Initially Queue is empty
+        size = 0;
+        maxlen = m;
+        front = rear = NULL; 
+    }
+    // Insert an element at Rear (Enqueue operation)
+    void enqueue(int data){
+        // check if the queue is full
+        if(size == maxlen){
+            cout << "Queue Overflow Error" << endl;
+        }
+        else{
+            // insert element at rear pointer
+            Node *new_node = new Node(data);
+            new_node->next = rear;
+            rear = new_node; // rear is always newly inserted node
+            if(size == 0){
+                // make front pointer the first inserted node
+                front = new_node;
+            }
+        }
+        size++;
+    }
+    // display Rear of the Queue
+    void displayRear(){
+        cout << rear->data << endl;
+    }
+    // display Front of the Queue
+    void displayFront()
+    {
+        cout << front->data << endl;
+    }
+    // Delete an element from the front of the Queue (Dequeue operation)
+    void dequeue(){
+        Node *curr = rear;
+        Node *prev;
+        while (curr != front){
+            prev = curr;
+            curr = curr->next;
+        }
+        cout << curr->data << " has been deleted" << endl;
+        front = prev; // front is always node to be removed
+        prev->next = NULL;
+        size--;
+    }
+};
+
+int main(){
+    Queue q(5);
+    q.enqueue(1);
+    q.enqueue(2);
+    q.enqueue(3);
+    q.enqueue(4);
+    q.displayRear();
+    q.displayFront();
+    q.dequeue();
+    q.displayRear();
+    q.displayFront();
+    return 0;
+}
diff --git a/Cpp/StackUsingArray.cpp b/Cpp/StackUsingArray.cpp
@@ -0,0 +1,52 @@
+// Implement a stack using arrays in C++
+
+#include <iostream>
+using namespace std;
+
+class Stack {
+    // class variables for the stack
+    private: // access specifiers so these variables cannot be accessed outside
+    int maxlen, top;
+    int *arr; // serves as the stack
+    // constructor to initialise the stack
+    public:
+    Stack(int maxlength){
+        maxlen = maxlength; // maximum size of the stack
+        top = -1; // keeps track of the last element (-1 represents empty)
+        arr = new int[maxlength]; // stack
+    }
+    // insert element into the "top" of the stack
+    void push(int data){
+        if (top != maxlen - 1) {
+            // condition to check if stack is full
+            arr[top] = data;
+            cout << data << " has been inserted" << endl;
+            top++; // one element has been added
+        }
+        else {
+            cout << "Stack Overflow Error" << endl;
+        }
+    }
+    // display the last entered element of the stack
+    void peek(){
+        cout << arr[top] << endl;
+    }
+    // delete an element from the "top" of the stack
+    void pop(){
+        if(top == -1){
+            cout << "Stack Underflow Error" << endl;
+        }
+        else {
+            cout << arr[top] << " has been deleted" << endl;
+            top--; // one element has been decreased
+        }
+    }
+};
+
+int main(){
+    Stack st(5);
+    st.push(1);
+    st.pop();
+    st.pop();
+    return 0;
+}
diff --git a/Cpp/StackUsingLL.cpp b/Cpp/StackUsingLL.cpp
