#include <stdio.

h>
#define MAX 5 // Maximum size of stack

int stack[MAX];
int top = -1; // Initially stack is empty

// Function to check if stack is full

int isFull() {
return top == MAX - 1;
}

// Function to check if stack is empty

int isEmpty() {
return top == -1;
}

// Function to push element into stack

void push(int value) {
if (isFull()) {
printf("Stack Overflow! Cannot push %d\n", value);
} else {
stack[++top] = value;
printf("%d pushed to stack\n", value);
}
}

// Function to pop element from stack

void pop() {
if (isEmpty()) {
printf("Stack Underflow! Cannot pop\n");
} else {
printf("%d popped from stack\n", stack[top--]);
}
}

// Function to get top element

void peek() {
if (isEmpty()) {
printf("Stack is Empty!\n");
} else {
printf("Top element is %d\n", stack[top]);
}
}

// Function to display stack

void display() {
if (isEmpty()) {
printf("Stack is Empty!\n");
 } else {
printf("Stack elements: ");
for (int i = 0; i <= top; i++) {
printf("%d ", stack[i]);
}
printf("\n");
}
}

int main() {
push(10);
push(20);
push(30);
display();
peek();
pop();
display();

return 0;
}
#include <stdio.h>
#define MAX 5 // Maximum size of queue

int queue[MAX];
int front = -1, rear = -1;

// Function to check if queue is full

int isFull() {
return (rear == MAX - 1);
}

// Function to check if queue is empty

int isEmpty() {
return (front == -1 || front > rear);
}

// Function to add element to queue (enqueue)

void enqueue(int value) {
if (isFull()) {
printf("Queue Overflow! Cannot insert %d\n", value);
} else {
if (front == -1) front = 0; // first element
queue[++rear] = value;
printf("%d enqueued into queue\n", value);
}
}

// Function to remove element from queue (dequeue)

void dequeue() {
if (isEmpty()) {
printf("Queue Underflow! Cannot dequeue\n");
} else {
printf("%d dequeued from queue\n", queue[front++]);
}
}

// Function to get front element

void peek() {
if (isEmpty()) {
printf("Queue is Empty!\n");
} else {
printf("Front element is %d\n", queue[front]);
}
}

// Function to display queue

void display() {
if (isEmpty()) {
 printf("Queue is Empty!\n");
} else {
printf("Queue elements: ");
for (int i = front; i <= rear; i++) {
printf("%d ", queue[i]);
}
printf("\n");
}
}

int main() {
enqueue(10);
enqueue(20);
enqueue(30);
display();
peek();
dequeue();
display();

return 0;
}
#include <stdio.h>
#define MAX 5

int queue[MAX];
int front = -1, rear = -1;

// Function to check if queue is full

int isFull() {
return ((front == 0 && rear == MAX - 1) || (rear + 1) % MAX == front);
}

// Function to check if queue is empty

int isEmpty() {
return (front == -1);
}

// Enqueue (Insert element)

void enqueue(int value) {
if (isFull()) {
printf("Queue Overflow! Cannot insert %d\n", value);
} else {
if (front == -1) // First element
front = 0;
rear = (rear + 1) % MAX; // circular increment
queue[rear] = value;
printf("%d enqueued into circular queue\n", value);
}
}

// Dequeue (Remove element)

void dequeue() {
if (isEmpty()) {
printf("Queue Underflow! Cannot dequeue\n");
} else {
printf("%d dequeued from circular queue\n", queue[front]);
if (front == rear) {
// Queue becomes empty
front = rear = -1;
} else {
front = (front + 1) % MAX; // circular increment
}
}
}

// Peek (Front element)

void peek() {
if (isEmpty()) {
printf("Queue is Empty!\n");
 } else {
printf("Front element is %d\n", queue[front]);
}
}

// Display all elements

void display() {
if (isEmpty()) {
printf("Queue is Empty!\n");
} else {
printf("Circular Queue elements: ");
int i = front;
while (1) {
printf("%d ", queue[i]);
if (i == rear) break;
i = (i + 1) % MAX;
}
printf("\n");
}
}

int main() {
enqueue(10);
enqueue(20);
enqueue(30);
enqueue(40);
display();
dequeue();
dequeue();
display();
enqueue(50);
enqueue(60);
display();
peek();

return 0;
}
#include <stdio.h>
#define MAX 5

int q1[MAX], q2[MAX];

int front1 = -1, rear1 = -1;
int front2 = -1, rear2 = -1;

// Queue functions
int isEmpty(int front) {
return (front == -1);
}
int isFull(int rear) {
return (rear == MAX - 1);
}

void enqueue(int q[], int *front, int *rear, int x) {

if (isFull(*rear)) {
printf("Queue Overflow!\n");
return;
}
if (*front == -1) *front = 0;
q[++(*rear)] = x;
}

int dequeue(int q[], int *front, int *rear) {

if (isEmpty(*front)) {
printf("Queue Underflow!\n");
return -1;
}
int val = q[*front];
if (*front == *rear) {
*front = *rear = -1; // reset queue
} else {
(*front)++;
}
return val;
}

// Stack push using queues

void push(int x) {
// Step 1: Insert into q2
enqueue(q2, &front2, &rear2, x);

// Step 2: Move all elements from q1 to q2

while (!isEmpty(front1)) {
enqueue(q2, &front2, &rear2, dequeue(q1, &front1, &rear1));
}
 // Step 3: Swap q1 and q2
int tempArr[MAX], tFront, tRear;

// swap arrays manually

for (int i = 0; i < MAX; i++) tempArr[i] = q1[i];
int tempFront = front1, tempRear = rear1;

for (int i = 0; i < MAX; i++) q1[i] = q2[i];

front1 = front2; rear1 = rear2;

for (int i = 0; i < MAX; i++) q2[i] = tempArr[i];

front2 = tempFront; rear2 = tempRear;

printf("%d pushed to stack\n", x);

}

// Stack pop
void pop() {
if (isEmpty(front1)) {
printf("Stack Underflow!\n");
} else {
printf("%d popped from stack\n", dequeue(q1, &front1, &rear1));
}
}

// Peek
void peek() {
if (isEmpty(front1)) {
printf("Stack is Empty!\n");
} else {
printf("Top element is %d\n", q1[front1]);
}
}

// Display stack
void display() {
if (isEmpty(front1)) {
printf("Stack is Empty!\n");
} else {
printf("Stack elements: ");
for (int i = front1; i <= rear1; i++) {
printf("%d ", q1[i]);
}
printf("\n");
}
}

int main() {
 push(10);
push(20);
push(30);
display();
peek();
pop();
display();
return 0;
}
#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
struct node *next;
};
void display(struct node *p)
{
if (p == NULL)
{
printf("List is empty!\n");
return;
}
printf("Linked list: ");
while (p != NULL)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
struct node *insertbeg(struct node *head, int x)
{
struct node *t = (struct node *)malloc(sizeof(struct node));
t->data = x;
t->next = head;
return t;
}
void insertpos(struct node *head, int pos, int x)
{
struct node *p = head;
int i = 1;
struct node *t = (struct node *)malloc(sizeof(struct node));
while (i != pos - 1 && p != NULL)
{
p = p->next;
i++;
}
if (p == NULL)
{
printf("Position out of range!\n");
free(t);
return;
}
t->data = x;
t->next = p->next;
p->next = t;
}
void insertlast(struct node *head, int x)
{
struct node *p = head;
struct node *t = (struct node *)malloc(sizeof(struct node));
t->data = x;
t->next = NULL;
if (p == NULL)
{
head = t;
return;
}
while (p->next != NULL)
p = p->next;
p->next = t;
}
struct node *delbeg(struct node *head)
{
if (head == NULL)
{
printf("List is empty!\n");
return head;
}
struct node *p = head;
head = head->next;
printf("Deleted %d from beginning\n", p->data);
free(p);
return head;
}
struct node *delend(struct node *head)
{
if (head == NULL)
{
printf("List is empty!\n");
return head;
}
if (head->next == NULL)
{
printf("Deleted %d from end\n", head->data);
free(head);
return NULL;
}
struct node *p = head;
while (p->next->next != NULL)
p = p->next;
printf("Deleted %d from end\n", p->next->data);
free(p->next);
p->next = NULL;
 return head;
}
struct node *delpos(struct node *head, int pos)
{
if (head == NULL)
{
printf("List is empty!\n");
return head;
}
if (pos == 1)
return delbeg(head);
struct node *p = head;
int i = 1;
while (i != pos - 1 && p->next != NULL)
{
p = p->next;
i++;
}
if (p->next == NULL)
{
printf("Position out of range!\n");
return head;
}
struct node *q = p->next;
printf("Deleted %d from position %d\n", q->data, pos);
p->next = q->next;
free(q);
return head;
}
int main()
{
struct node *head = NULL;
int choice, x, pos;
do
{
printf("\nChoose an option-\n");
printf("1. Insert at beginning\n");
printf("2. Insert at position\n");
printf("3. Insert at end\n");
printf("4. Delete from beginning\n");
printf("5. Delete from end\n");
printf("6. Delete from position\n");
printf("7. Display list\n");
printf("8. Exit\n");
printf("Enter choice: ");
scanf("%d", &choice);
switch (choice)
{
 case 1:
printf("Enter value: ");
scanf("%d", &x);
head = insertbeg(head, x);
break;
case 2:
printf("Enter position: ");
scanf("%d", &pos);
printf("Enter value: ");
scanf("%d", &x);
if (head == NULL && pos != 1)
printf("List is empty! Insert at beginning first.\n");
else
insertpos(head, pos, x);
break;
case 3:
printf("Enter value: ");
scanf("%d", &x);
if (head == NULL)
head = insertbeg(head, x);
else
insertlast(head, x);
break;
case 4:
head = delbeg(head);
break;
case 5:
head = delend(head);
break;
case 6:
printf("Enter position: ");
scanf("%d", &pos);
head = delpos(head, pos);
break;
case 7:
display(head);
break;
case 8:
printf("Exiting\n");
break;
default:
printf("Invalid choice! Try again.\n");
}
} while (choice != 8);
return 0;
}