Palindrome using stack:

#include <iostream>
#include <string.h>
using namespace std;
#define size 20

struct Stack
{
    char stk[size];
    int top;
}s1;

int overflow()
{
    if (s1.top == size - 1)
    {
        cout << "Stack Overflow" << endl;
        return 1;
    }
    else
        return 0;
}

int underflow()
{
    if (s1.top == -1)
    {
        cout << "Stack Underflow" << endl;
        return 1;
    }
    else
        return 0;
}

void push(char val)
{
    s1.top++;
    s1.stk[s1.top]=val;
}

char pop()
{
    char val;
    val = s1.stk[s1.top];
    s1.top--;
    return val;
}

int main()
{
    int j;
    s1.top = -1;
    char str1[20], str2[20];
    cout<< "Enter the string: ";
    cin>>str1;

    for (int i=0;i<strlen(str1);i++)
    {
        push(str1[i]);
    }

    for (j=0;j<strlen(str1);j++)
    {
        str2[j] = pop();
    }

    str2[j] = '\\0';
    if (strcmp(str1,str2) == 0)
        cout<<"String is palindrome."<<endl;
    
    else
        cout<<"String is not a palindrome."<<endl;
    
}

Evaluate postfix expression :

#include <iostream>
#include <math.h>
using namespace std;
#define size 100

struct stack
{
    int stk[size];
    int top;
} s1;

int overflow()
{
    if (s1.top == size - 1)
    {
        cout << "Stack Overflow" << endl;
        return 1;
    }
    else
        return 0;
}

int underflow()
{
    if (s1.top == -1)
    {
        cout << "Stack Underflow" << endl;
        return 1;
    }
    else
        return 0;
}

void push(int val)
{
    if (overflow())
    {
        return;
    }
    else
    {
        s1.top++;
        s1.stk[s1.top] = val;
    }
}

int pop()
{
    int val;
    if (underflow())
    {
        return 1;
    }
    else
    {
        val = s1.stk[s1.top];
        s1.top--;
        return val;
    }
}

void peek()
{
    if (underflow())
    {
        return;
    }
    else
    {
        cout << s1.stk[s1.top] << endl;
    }
}

int main()
{
    s1.top = -1;
    int i, a, b, result;
    char postfix[100];
    cout << "Enter postfix expression :";
    cin >> postfix;
    for (i = 0; postfix[i] != '\\0'; i++)
    {
        if (postfix[i] == '+' || postfix[i] == '-' || postfix[i] == '*' || postfix[i] == '/' || postfix[i] == '%' || postfix[i] == '^')
        {
            a = pop();
            b = pop();

            switch (postfix[i])
            {
            case '+':
                result = b + a;
                push(result);
                break;

            case '-':
                result = b - a;
                push(result);
                break;

            case '*':
                result = b * a;
                push(result);
                break;
            case '/':
                result = b / a;
                push(result);
                break;
            case '%':
                result = b % a;
                push(result);
                break;
            case '^':
                result = pow(b, a);
                push(result);
                break;
            default:
                cout << "Enter valid input";
            }
        }
        else
            push(postfix[i] - '0');
    }
    peek();
}

Simple Queue :

#include <iostream>
using namespace std;
#define size 10

struct queue
{
    int Q[size];
    int f, r;
} q1;

int isfull()
{
    if (q1.r == size - 1)
    {
        cout << "\\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Queue is full >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
        return 1;
    }
    else
        return 0;
}

int isempty()
{
    if (q1.f == -1 && q1.r == -1)
    {
        cout << "\\n<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Queue is empty <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<";
        return 1;
    }
    else
        return 0;
}

void insert(int element)
{
    if (isfull())
    {
        return;
    }
    else
    {
        if (q1.f == -1 && q1.r == -1)
        {
            q1.f = 0;
            q1.r = 0;
        }
        else
            q1.r++;

        q1.Q[q1.r] = element;
    }
}

void dequeue()
{
    int element;

    if (isempty())
        return;
    else
    {
        element = q1.Q[q1.f];
        if (q1.f == q1.r)
        {
            q1.f = -1;
            q1.r = -1;
        }
        else
            q1.f++;
    }

    cout << "\\n........................Element deleted is -->" << element;
}

void display()
{
    int i;
    if (isempty())
        return;
    else
    {
        for (i = q1.f; i <= q1.r; i++)
        {
            cout << q1.Q[i];
        }
    }
}

int main()
{
    q1.f = -1;
    q1.r = -1;

    cout<<"\\n__________________________________________________________________________________________Simple Queue__________________________________________________________________________________________\\n";

    int ch, i = 1, num;
    while (i)
    {
        cout << "\\nEnter\\n 1 --> inserting element \\n 2 --> deleting element \\n 3 --> display elements \\n 0 --> end" << endl;
        cin >> ch;
        switch (ch)
        {
        case 1:
            cout << "\\n........................Enter number : ";
            cin >> num;
            insert(num);
            break;

        case 2:
            dequeue();
            break;

        case 3:
            display();
            break;

        case 0:
            i = 0;
            break;

        default:
            cout << "........................ Enter valid input :( ........................";
        }
    }
    return 0;
}

Circular Queue :

#include <iostream>
using namespace std;
#define size 5

struct queue
{
    int Q[size];
    int f, r;
} q1;

int isfull()
{
    if ((q1.f == q1.r + 1) || (q1.f == 0) && q1.r == size - 1)
    {
        cout << "\\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Queue is full >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
        return 1;
    }
    else
        return 0;
}

int isempty()
{
    if (q1.f == -1)
    {
        cout << "\\n<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Queue is empty <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<";
        return 1;
    }
    else
        return 0;
}

void insert(int element)
{
    if (isfull())
    {
        return;
    }
    else
    {
        if (q1.f == -1)
        {
            q1.f = 0;
        }

        q1.r = (q1.r + 1) % size;
        q1.Q[q1.r] = element;
        cout << "........................Element inserted is -->" << element;
    }
}

int dequeue()
{
    int element;

    if (isempty())
        return (-1);

    else
    {
        element = q1.Q[q1.f];
        if (q1.f == q1.r)
        {
            q1.f = -1;
            q1.r = -1;
        }
        else
            q1.f = (q1.f + 1) % size;
    }

    cout << "\\n........................Element deleted is -->" << element;
}

void display()
{
    int i;
    if (isempty())
        return;
    else
    {
        if (q1.f <= q1.r)
        {
            for (i = q1.f; i <= q1.r; i++)
            {
                cout << q1.Q[i];
            }
        }

        if (q1.f > q1.r)
        {
            for (i = q1.f; i <= size - 1; i++)
            {
                cout << q1.Q[i];
            }

            for (i = 0; i <= q1.r; i++)
            {
                cout << q1.Q[i];
            }
        }
    }
}

int main()
{
    q1.f = -1;
    q1.r = -1;

    cout<<"\\n__________________________________________________________________________________________Circular Queue__________________________________________________________________________________________\\n";

    int ch, i = 1, num;
    while (i)
    {
        cout << "\\nEnter\\n 1 --> inserting element \\n 2 --> deleting element \\n 3 --> display elements \\n 0 --> end" << endl;
        cin >> ch;
        switch (ch)
        {
        case 1:
            cout << "\\n........................Enter number : ";
            cin >> num;
            insert(num);
            break;

        case 2:
            dequeue();
            break;

        case 3:
            display();
            break;

        case 0:
            i = 0;
            break;

        default:
            cout << "........................ Enter valid input :( ........................";
        }
    }
    return 0;
}