Array

#include <iostream>
using namespace std;

int main()
{
    int size;
    cout << "Enter the size of array";
    cin >> size;
    int a[size];

    cout << "Enter elements:";
    for (int i = 0; i < size; i++)
        cin >> a[i];

    int ch, pos, element;
    while (true)
    {
        cout << "Enter 1-insertion 2-deletion 3-exit";
        cin >> ch;
        if (ch == 1)
        {
            cout << "\\nEnter position 1-insertion at first 2-insertion at last 3-insertion in between";
            cin >> pos;

            if (pos > 3 || pos < 1)
                return (1);

            cout << "Enter element: ";
            cin >> element;

            if (pos == 1)
            {
                for (int i = size; i >= 1; i--)
                {
                    a[i] = a[i - 1];
                }
                a[0] = element;
                size++;

                for (int i = 0; i < size; i++)
                    cout << a[i];
            }

            if (pos == 2)
            {
                a[size] = element;
                size++;

                for (int i = 0; i < size; i++)
                    cout << a[i];
            }

            if (pos == 3)
            {
                int index;
                cout << "Enter index: ";
                cin >> index;

                for (int i = size; i >= index; i--)
                {
                    a[i] = a[i - 1];
                }
                a[index] = element;
                size++;
                for (int i = 0; i < size; i++)
                    cout << a[i];
            }
        }

        if (ch == 2)
        {
            cout << "\\nEnter position 1-deletion at first 2-deletion at last 3-deletion in between";
            cin >> pos;

            if (pos == 1)
            {
                for (int i = 0; i < size; i++)
                {
                    a[i] = a[i + 1];
                }
                size--;
                for (int i = 0; i < size; i++)
                    cout << a[i];
            }
            if (pos == 2)
            {
                size--;
                for (int i = 0; i < size; i++)
                    cout << a[i];
            }
            if (pos == 3)
            {
                int index;
                cout << "Enter index: ";
                cin >> index;

                for (int i = index; i < size; i++)
                {
                    a[i] = a[i + 1];
                }
                size--;
                for (int i = 0; i < size; i++)
                    cout << a[i];
            }
        }

        if (ch == 3)
        {
            break;
        }
    }
    return 0;
}

Stack

#include <iostream>
using namespace std;
class Stack
{
public:
    int top;
    int size;
    int *arr;

    Stack(int size)
    {
        top = -1;
        arr = new int[size];
    }

    bool isEmpty()
    {
        if (top == -1)
            return true;
        else
            return false;
    }

    bool isFull()
    {
        if (top == size - 1)
            return true;
        else
            return false;
    }

    int push(int element)
    {
        if (isFull())
        {
            cout << "Stack is full!" << endl;
            return -1;
        }
        top++;
        arr[top] = element;
    }

    int pop()
    {
        if (isEmpty())
        {
            cout << "Stack is empty!" << endl;
            return -1;
        }
        int temp = arr[top];
        cout << "Element deleted is " << temp;
        top--;
    }
    int peek()
    {
        if (isEmpty())
        {
            cout << "Stack is empty!" << endl;
            return -1;
        }
        cout << "Topmost element is " << arr[top];
    }
    void display()
    {
        cout << "Stack elements:(top to bottom) ";
        for (int i = top; i >= 0; i--)
        {
            cout << arr[i];
        }
    }
};

int main()
{
    Stack stk(5);
    stk.push(1);
    stk.push(2);
    stk.push(3);
    stk.push(4);
    stk.push(5);
    stk.peek();
    stk.display();
    stk.pop();
    stk.display();
    stk.pop();
    stk.pop();
    stk.pop();
    stk.pop();
    stk.pop();

    return 0;
}

Queue

#include <iostream>
using namespace std;

class Queue
{
public:
    int front, rear;
    int *arr;
    int size;

    Queue(int size)
    {
        front = -1;
        rear = -1;
        arr = new int[size];
    }

    bool underflow()
    {
        if (front == -1 && rear == -1)
            return true;
        else
            return false;
    }

    bool overflow()
    {
        if (rear == size - 1)
            return true;
        else
            return false;
    }

    void enqueue(int element)
    {
        if (overflow())
        {
            cout << "Queue is full";
            return;
        }
        if (underflow())
        {
            front = 0;
            rear = 0;
        }
        else
            rear++;
        arr[rear] = element;
    }

    void dequeue()
    {
        if (underflow())
        {
            cout << "Queue is empty";
            return;
        }
        int temp = arr[front];
        if (front == rear)
        {
            front = -1;
            rear = -1;
        }
        else
            front++;
        cout << "Element deleted is: " << temp;
    }

    void display()
    {
        if (underflow())
        {
            cout << "Queue is empty";
            return;
        }
        for (int i = front; i <= rear; i++)
            cout << arr[i];
    }
};

int main()
{
    Queue q1(5);
    q1.enqueue(1);
    q1.enqueue(2);
    q1.enqueue(3);
    q1.enqueue(4);
    q1.enqueue(5);
    q1.display();
    q1.dequeue();
    q1.display();
    q1.dequeue();
    q1.dequeue();
    q1.dequeue();
    q1.dequeue();
    q1.dequeue();
    return 0;
}

Circular Queue

#include <iostream>
using namespace std;

class CQueue
{
public:
    int front, rear;
    int *arr;
    int size;

    CQueue(int size)
    {
        front = -1;
        rear = -1;
        arr = new int[size];
    }

    bool overflow()
    {
        if (front == 0 && rear == size - 1 || front == rear + 1)
            return true;
        else
            return false;
    }

    bool underflow()
    {
        if (front == -1 && rear == -1)
            return true;
        else
            return false;
    }

    void enqueue(int element)
    {
        if (overflow())
        {
            cout << "queue is full";
            return;
        }
        if (underflow())
        {
            front = 0;
            rear = 0;
        }
        else
            rear = (rear + 1) % size;
        arr[rear] = element;
    }
    void dequeue()
    {
        if (underflow())
        {
            cout << "Queue is empty";
            return;
        }
        int temp = arr[front];
        if (front == rear)
        {
            front = rear = -1;
        }
        else
            front = (front + 1) % size;
        cout << "Deleted element is " << temp;
    }
    void display()
    {
        if (underflow())
        {
            cout << "Queue is empty";
            return;
        }
        cout << "\\nElements are:";
        if (front <= rear)
        {
            for (int i = front; i <= rear; i++)
                cout << arr[i];
        }
        if (front > rear)
        {
            for (int i = front; i <= size - 1; i++)
                cout << arr[i];
            for (int i = 0; i < rear; i++)
                cout << arr[i];
        }
    }
};

int main()
{
    CQueue q1(5);
    q1.enqueue(1);
    q1.enqueue(2);
    q1.enqueue(3);
    q1.enqueue(4);
    q1.enqueue(5);
    q1.display();

    q1.dequeue();
    q1.dequeue();
    q1.dequeue();
    q1.dequeue();
    q1.dequeue();
    q1.dequeue();
    q1.display();

    q1.enqueue(3);
    q1.enqueue(4);
    q1.display();
    return 0;
}

LinkedList

#include <iostream>
using namespace std;

class Node
{
public:
    int info;
    Node *next;
    Node(int element)
    {
        info = element;
        next = NULL;
    }
};

class LinkedList
{
private:
    Node *start;

public:
    LinkedList()
    {
        start = NULL;
    }

    void insert_beg(int element)
    {
        Node *temp = new Node(element);
        if (start == NULL)
            start = temp;
        else
        {
            temp->next = start;
            start = temp;
        }
    }
    void insert_end(int element)
    {
        Node *temp1 = new Node(element);
        if (start == NULL)
            start = temp1;
        else
        {
            Node *temp2 = start;
            while (temp2->next != NULL)
                temp2 = temp2->next;
            temp2->next = temp1;
        }
    }
    void insert_between(int pos, int element)
    {
        Node *temp1 = new Node(element);
        int count = 0;
        if (start == NULL)
            start = temp1;
        else
        {
            Node *temp2 = start;
            while (count < pos - 1)
            {
                temp2 = temp2->next;
                count++;
            }
            temp1->next = temp2->next;
            temp2->next = temp1;
        }
    }

    void del_beg()
    {
        if (start == NULL)
        {
            cout << "Empty";
            return;
        }
        Node *temp = start;
        start = temp->next;
        cout << "Element deleted is :" << temp->info << endl;
        delete (temp);
    }

    void del_end()
    {
        if (start == NULL)
        {
            cout << "Empty";
            return;
        }
        Node *temp1 = start;

        if (temp1->next == NULL)
            del_beg();
        else
        {
            while (temp1->next->next != NULL)
                temp1 = temp1->next;

            Node *temp2 = temp1->next;
            temp1->next = NULL;
            cout << "Deleted element is :" << temp2->info << endl;
            delete (temp2);
        }
    }
    void del_between(int pos)
    {
        if (start == NULL)
        {
            cout << "Empty";
            return;
        }
        Node *temp1 = start;
        if (temp1->next == NULL)
            del_beg();
        else
        {
            int count = 1;
            while (count < pos - 1)
            {
                temp1 = temp1->next;
                count++;
            }
            Node *temp2 = temp1->next;
            temp1->next = temp2->next;
            cout << "Deleted element is :" << temp2->info << endl;
            delete (temp2);
        }
    }
    void display()
    {
        if (start == NULL)
        {
            cout << "Empty";
            return;
        }
        cout << "\\nList:";
        Node *temp = start;
        while (temp != NULL)
        {
            cout << temp->info;
            temp = temp->next;
        }
    }
};

int main()
{
    LinkedList list;
    list.insert_beg(1);
    list.insert_end(3);
    list.insert_between(1, 2);
    list.display();
    list.del_between(1);
    list.display();
    list.del_beg();
    list.display();
    list.del_end();
    list.display();
    return 0;
} f

Stack using LL

#include <iostream>
using namespace std;

class StackNode
{
public:
    int info;
    StackNode *next;

    StackNode(int element)
    {
        info = element;
        next = NULL;
    }
};

class Stack
{
private:
    StackNode *top;

public:
    Stack()
    {
        top = NULL;
    }

    void push(int element)
    {
        StackNode *temp = new StackNode(element);
        if (top == NULL)
            top = temp;
        else
        {
            temp->next = top;
            top = temp;
        }
    }

    void pop()
    {
        if (top == NULL)
        {
            cout << "Empty";
            return;
        }
        StackNode *temp = top;
        top = top->next;
        cout << "Deleted element is:" << temp->info;
        delete (temp);
    }

    void peek()
    {
        if (top == NULL)
        {
            cout << "Empty";
        }
        else
        {
            cout << top->info;
        }
    }

    void display()
    {
        if (top == NULL)
        {
            cout << "Empty";
            return;
        }
        StackNode *temp = top;
        while (temp != NULL)
        {
            cout << temp->info;
            temp = temp->next;
        }
    }
};

int main()
{
    Stack s1;
    s1.push(1);
    s1.push(2);
    s1.push(3);
    s1.peek();
    s1.display();
    s1.pop();
    s1.pop();
    s1.display();
    s1.pop();
    s1.pop();
    return 0;
}

Queue using LL

#include <iostream>
using namespace std;

class QueueNode
{
public:
    int info;
    QueueNode *next;
    QueueNode(int element)
    {
        info = element;
        next = NULL;
    }
};

class Queue
{
private:
    QueueNode *front;
    QueueNode *rear;

public:
    Queue()
    {
        front = NULL;
        rear = NULL;
    }
    void enqueue(int element)
    {
        QueueNode *temp = new QueueNode(element);
        if (front == NULL)
        {
            front = temp;
            rear = temp;
        }
        else
        {
            rear->next = temp;
            rear = temp;
        }
    }
    void dequeue()
    {
        if (front == NULL)
        {
            cout << "Queue is empty!" << endl;
            return;
        }
        else
        {
            QueueNode *temp = front;
            front = temp->next;
            cout << "Deleted element is " << temp->info;
            delete temp;
        }
    }
    void display()
    {
        if (front == NULL)
        {
            cout << "Queue is empty!" << endl;
            return;
        }
        else
        {
            QueueNode *temp = front;
            cout << "\\nElements are";
            while (temp != NULL)
            {
                cout << temp->info;
                temp = temp->next;
            }
        }
    }
};

int main()
{
    Queue q1;
    q1.enqueue(1);
    q1.enqueue(2);
    q1.enqueue(3);
    q1.display();

    q1.dequeue();
    q1.display();
    q1.dequeue();
    q1.dequeue();
    q1.dequeue();
    q1.dequeue();
    q1.display();
    return 0;
}