Q Implement queue library using array or linked list.

Use this queue library to simulate

Waiting list operations of the railway reservation system.

#include <stdio.h>
#include <stdbool.h>

Data Structures Activity #define MAX_QUEUE_SIZE 100

typedef struct {
int data[MAX_QUEUE_SIZE];
int front;
int rear;
} Queue;

void initQueue(Queue *q) {

q->front = q->rear = -1;
}

bool isEmpty(Queue *q) {

return q->front == -1;

“Write code & trace the output” }

bool isFull(Queue *q) {

return (q->rear + 1) % MAX_QUEUE_SIZE == q->front;
}
SHRAVAN KUTE
void enqueue(Queue *q, int item) {

SYBSc CS if (isFull(q)) {
printf("Queue is full. Cannot enqueue.\n");
} else {
if (isEmpty(q)) {
q->front = 0;
}
q->rear = (q->rear + 1) % MAX_QUEUE_SIZE;
q->data[q->rear] = item;
}
}

int dequeue(Queue *q) {

int item = -1;
if (isEmpty(q)) {
printf("Queue is empty. Cannot dequeue.\n");
 } else { }
item = q->data[q->front];
if (q->front == q->rear) { return 0;
q->front = q->rear = -1; }
} else {
q->front = (q->front + 1) % MAX_QUEUE_SIZE;
}
}
return item;
}

int main() {
Queue waitingList;
initQueue(&waitingList);

int choice, passenger;

while (1) {
printf("Railway Reservation System Waiting List\n");
printf("1. Add passenger to waiting list\n");
printf("2. Remove passenger from waiting list\n");
printf("3. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);

switch (choice) {
case 1:
printf("Enter passenger number: ");
scanf("%d", &passenger);
enqueue(&waitingList, passenger); Q Write a program to find all solutions to the four queens problem. Your program will need
printf("Passenger %d added to the waiting list.\n", passenger); to be able to handle a search for a configuration that has no solution.
break;
case 2: #include <stdio.h>
passenger = dequeue(&waitingList); #include <stdbool.h>
if (passenger != -1) {
printf("Passenger %d removed from the waiting list.\n", passenger); #define N 4
}
break; int board[N][N];
case 3:
printf("Exiting the program.\n"); // Function to print the board
return 0; void printBoard() {
default: for (int i = 0; i < N; i++) {
printf("Invalid choice. Please try again.\n"); for (int j = 0; j < N; j++) {
} printf(board[i][j] ? "Q " : ". ");
 } }
printf("\n"); }
}
printf("\n"); return hasSolution;
} }

// Function to check if it's safe to place a queen at board[row][col] int main() {

bool isSafe(int row, int col) { if (!solveQueens(0)) {
// Check the column printf("No solution exists for the Four Queens Problem.\n");
for (int i = 0; i < row; i++) { }
if (board[i][col])
return false; return 0;
} }

// Check upper-left diagonal

for (int i = row, j = col; i >= 0 && j >= 0; i--, j--) {
if (board[i][j])
return false;
}

// Check upper-right diagonal

for (int i = row, j = col; i >= 0 && j < N; i--, j++) {
if (board[i][j])
return false;
}

return true;
}

// Recursive function to solve the Four Queens Problem

bool solveQueens(int row) {
if (row == N) {
// All queens are placed successfully Q Write a program to convert an infix expression of the form (a*(b+c)*((d-a)/b)) intoits
printBoard(); Equivalent postfix notation. Consider the usual precedence of operators. Use stack library
return true; oF Stack of characters using static implementation.
}
#include <stdio.h>
bool hasSolution = false; #include <stdlib.h>
#include <string.h>
for (int col = 0; col < N; col++) {
if (isSafe(row, col)) { #define MAX_EXPRESSION_LENGTH 100
board[row][col] = 1;
hasSolution = solveQueens(row + 1) || hasSolution; // Function to check if a character is an operator
board[row][col] = 0; // Backtrack int isOperator(char ch) {
 return (ch == '+' || ch == '-' || ch == '*' || ch == '/');
} int main() {
char infix[MAX_EXPRESSION_LENGTH];
// Function to get the precedence of an operator char postfix[MAX_EXPRESSION_LENGTH];
int getPrecedence(char ch) {
if (ch == '*' || ch == '/') printf("Enter the infix expression: ");
return 2; scanf("%s", infix);
else if (ch == '+' || ch == '-')
return 1; infixToPostfix(infix, postfix);
return 0;
} printf("Postfix expression: %s\n", postfix);

// Function to convert infix to postfix return 0;

void infixToPostfix(char infix[], char postfix[]) { }
char stack[MAX_EXPRESSION_LENGTH];
int top = -1;
int i, j = 0;

for (i = 0; infix[i] != '\0'; i++) {

char currentChar = infix[i];

if (isalnum(currentChar)) {
postfix[j++] = currentChar;
} else if (currentChar == '(') {
stack[++top] = currentChar;
} else if (currentChar == ')') { Q Write a program that copies the contents of one stack into another. Use stack library to
while (top >= 0 && stack[top] != '(') { perform basic stack operations. The order of two stacks must be identical.(Hint: Use a
postfix[j++] = stack[top--]; temporary stack to preserve the order).
}
top--; // Pop '(' #include <stdio.h>
} else if (isOperator(currentChar)) { #include <stdlib.h>
while (top >= 0 && getPrecedence(stack[top]) >= getPrecedence(currentChar)) {
postfix[j++] = stack[top--]; #define MAX_STACK_SIZE 100
}
stack[++top] = currentChar; struct Stack {
} int data[MAX_STACK_SIZE];
} int top;
};
while (top >= 0) {
postfix[j++] = stack[top--]; void initializeStack(struct Stack *stack) {
} stack->top = -1;
}
postfix[j] = '\0';
} int isFull(struct Stack *stack) {
 return stack->top == MAX_STACK_SIZE - 1; initializeStack(&destinationStack);
}
// Push some elements into the source stack
int isEmpty(struct Stack *stack) { push(&sourceStack, 1);
return stack->top == -1; push(&sourceStack, 2);
} push(&sourceStack, 3);
push(&sourceStack, 4);
void push(struct Stack *stack, int value) {
if (!isFull(stack)) { printf("Copying the source stack into the destination stack...\n");
stack->data[++stack->top] = value;
} else { copyStack(&sourceStack, &destinationStack);
printf("Stack is full. Cannot push %d.\n", value);
} printf("Contents of the source stack: ");
} while (!isEmpty(&sourceStack)) {
printf("%d ", pop(&sourceStack));
int pop(struct Stack *stack) { }
if (!isEmpty(stack)) { printf("\n");
return stack->data[stack->top--];
} else { printf("Contents of the destination stack: ");
printf("Stack is empty.\n"); while (!isEmpty(&destinationStack)) {
return -1; // Return a sentinel value printf("%d ", pop(&destinationStack));
} }
} printf("\n");

void copyStack(struct Stack *source, struct Stack *destination) { return 0;

struct Stack temp; }
initializeStack(&temp);

// Copy elements from the source stack to the destination stack while preserving order
while (!isEmpty(source)) {
int value = pop(source);
push(&temp, value);
}

while (!isEmpty(&temp)) {
int value = pop(&temp);
push(destination, value); Q There are lists where new elements are always appended at the end of the list. The list
push(source, value); // Restore the original order in the source stack can be implemented as a circular list with the external pointer pointing to the last element of
} the list. Implement doubly linked circular list of integers with append and display operations.
} The operation append(L, n), appends to the end of the list, n integers either accepted from
the user or randomly generated.
int main() {
struct Stack sourceStack, destinationStack; #include <stdio.h>
initializeStack(&sourceStack); #include <stdlib.h>
#include <time.h>
printf("Elements in the list: ");
// Structure for a node in the doubly linked circular list struct Node* current = last->next;
struct Node { do {
int data; printf("%d ", current->data);
struct Node* next; current = current->next;
struct Node* prev; } while (current != last->next);
}; printf("\n");
}
// Function to create a new node
struct Node* createNode(int value) { int main() {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); struct Node* last = NULL;
newNode->data = value; int n;
newNode->next = newNode->prev = newNode;
return newNode; printf("Enter the number of integers to append: ");
} scanf("%d", &n);

// Function to append n integers to the end of the list append(&last, n);

void append(struct Node** last, int n) { display(last);
for (int i = 0; i < n; i++) {
int value; return 0;
printf("Enter an integer to append: "); }
scanf("%d", &value);

struct Node* newNode = createNode(value);

if (*last == NULL) {
*last = newNode;
} else {
newNode->next = (*last)->next;
newNode->prev = *last;
(*last)->next->prev = newNode;
(*last)->next = newNode;
*last = newNode;
}
}
}

// Function to display the elements in the list

void display(struct Node* last) {
if (last == NULL) {
printf("The list is empty.\n"); Q What modifications are required to choose the pivot element randomly instead of
return; choosing the first element as pivot element while partitioning in the Quick sort algorithm?
}
#include <stdio.h> printf("Original Array: ");
#include <stdlib.h> for (int i = 0; i < n; i++) {
#include <time.h> printf("%d ", arr[i]);
}
void swap(int* a, int* b) {
int temp = *a; quickSort(arr, 0, n - 1);
*a = *b;
*b = temp; printf("\nSorted Array: ");
} for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
int randomPartition(int arr[], int low, int high) { }
// Generate a random index between low and high
srand(time(0)); return 0;
int randomIndex = low + rand() % (high - low + 1); }

// Swap the randomly selected element with the last element to use it as the pivot
swap(&arr[randomIndex], &arr[high]);

int pivot = arr[high];

int i = (low - 1);

for (int j = low; j <= high - 1; j++) {

if (arr[j] < pivot) {
i++;
swap(&arr[i], &arr[j]); Q Read the data from the file “employee.txt” and sort on names in alphabetical order (use
} strcmp) using bubble sort, insertion sort and selection sort.
}
swap(&arr[i + 1], &arr[high]); A) Implement a priority queue of integers using a static implementation
return (i + 1); Of the queue and implementing the below two operations. Write a driver program that
} Includes a queue library and calls different queue operations.
1) Add an element with its priority into the queue.
void quickSort(int arr[], int low, int high) { 2) Delete an element from the queue according to its priority.
if (low < high) {
int pivotIndex = randomPartition(arr, low, high); #include <stdio.h>
#include <stdlib.h>
quickSort(arr, low, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, high); #define MAX_QUEUE_SIZE 100
}
} struct QueueElement {
int data;
int main() { int priority;
int arr[] = {12, 11, 10, 5, 6}; };
int n = sizeof(arr) / sizeof(arr[0]);
struct PriorityQueue {
 struct QueueElement elements[MAX_QUEUE_SIZE]; }
int size; printf("\n");
}; }

void initializeQueue(struct PriorityQueue *queue) { int main() {

queue->size = 0; struct PriorityQueue queue;
} initializeQueue(&queue);

void enqueue(struct PriorityQueue *queue, int data, int priority) { // Enqueue elements with priorities
if (queue->size >= MAX_QUEUE_SIZE) { enqueue(&queue, 5, 2);
printf("Queue is full. Cannot add element.\n"); enqueue(&queue, 8, 1);
return; enqueue(&queue, 3, 3);
} enqueue(&queue, 7, 1);
enqueue(&queue, 6, 2);
int i = queue->size;
while (i > 0 && priority < queue->elements[i - 1].priority) { printQueue(&queue);
queue->elements[i] = queue->elements[i - 1];
i--; // Dequeue elements based on priority
} int dequeued = dequeue(&queue);
if (dequeued != -1) {
queue->elements[i].data = data; printf("Dequeued element: %d\n", dequeued);
queue->elements[i].priority = priority; }
queue->size++;
} printQueue(&queue);

int dequeue(struct PriorityQueue *queue) { return 0;

if (queue->size == 0) { }
printf("Queue is empty. Cannot delete element.\n");
return -1; // Return a sentinel value
}

int data = queue->elements[0].data;

for (int i = 1; i < queue->size; i++) {
queue->elements[i - 1] = queue->elements[i];
}
queue->size--;

return data;
}

void printQueue(struct PriorityQueue *queue) {

printf("Priority Queue: ");
for (int i = 0; i < queue->size; i++) {
printf("(%d, %d) ", queue->elements[i].data, queue->elements[i].priority);
 printf("Deque is empty.\n");
return -1; // Return a sentinel value
}
Q A doubly ended queue allows additions and deletions from both the ends that is front and return Q->arr[Q->rear];
rear. Initially additions from the front will not be possible. To avoid this situation, the array }
can be treated as if it were circular. Implement a queue library (dstqueue.h) of integers using
a static implementation of the circular queue and implementing the nine operations : void addFront(struct Deque *Q, int x) {
1. init(Q), 2) isempty(Q) 3) isFull(Q) 4)getFront(Q), 5)getRear(Q), if (isFull(Q)) {
6)addFront(Q,x), 7)deleteFront(Q) 8) addRear(Q,x) printf("Deque is full. Cannot add element at the front.\n");
9)deleteRear(Q) . return;
}
#include <stdio.h>
#include <stdbool.h> if (Q->front == -1) {
Q->front = Q->rear = 0;
#define MAX_SIZE 100 } else if (Q->front == 0) {
Q->front = MAX_SIZE - 1;
struct Deque { } else {
int arr[MAX_SIZE]; Q->front--;
int front, rear, size; }
};
Q->arr[Q->front] = x;
void init(struct Deque *Q) { Q->size++;
Q->front = Q->rear = -1; }
Q->size = 0;
} void deleteFront(struct Deque *Q) {
if (isEmpty(Q)) {
bool isEmpty(struct Deque *Q) { printf("Deque is empty. Cannot delete element from the front.\n");
return (Q->size == 0); return;
} }

if (Q->front == Q->rear) {
return (Q->size == MAX_SIZE); Q->front = Q->rear = -1;
} } else if (Q->front == MAX_SIZE - 1) {
Q->front = 0;
int getFront(struct Deque *Q) { } else {
if (isEmpty(Q)) { Q->front++;
printf("Deque is empty.\n"); }
return -1; // Return a sentinel value
} Q->size--;
return Q->arr[Q->front]; }
}
void addRear(struct Deque *Q, int x) {
int getRear(struct Deque *Q) { if (isFull(Q)) {
if (isEmpty(Q)) { printf("Deque is full. Cannot add element at the rear.\n");
 return; printf("Rear: %d\n", getRear(&Q));
}
deleteFront(&Q);
if (Q->front == -1) { deleteRear(&Q);
Q->front = Q->rear = 0;
} else if (Q->rear == MAX_SIZE - 1) { printf("Front: %d\n", getFront(&Q));
Q->rear = 0; printf("Rear: %d\n", getRear(&Q));
} else {
Q->rear++; return 0;
} }

Q->arr[Q->rear] = x;
Q->size++;
}

void deleteRear(struct Deque *Q) {

if (isEmpty(Q)) {
printf("Deque is empty. Cannot delete element from the rear.\n");
return;
}

if (Q->front == Q->rear) {
Q->front = Q->rear = -1;
} else if (Q->rear == 0) {
Q->rear = MAX_SIZE - 1;
} else {
Q->rear--;
}

Q->size--;
}

int main() {
struct Deque Q;
init(&Q);

printf("Is empty: %s\n", isEmpty(&Q) ? "Yes" : "No");

printf("Is full: %s\n", isFull(&Q) ? "Yes" : "No");

addRear(&Q, 1);
addRear(&Q, 2);
addFront(&Q, 0);

printf("Front: %d\n", getFront(&Q));