Scribd
Upload
6 views3 pages

Lab 2 Q 5 A

Uploaded by

Milica Markovic
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
6 views3 pages

Lab 2 Q 5 A

Uploaded by

Milica Markovic
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 3

#include <stdio.

h>
#include <stdlib.h>

typedef struct Node {


int data;
struct Node* next;
} Node;

typedef struct Queue {


Node* front;
Node* rear;
} Queue;

Queue* createQueue() {
Queue* queue = (Queue*)malloc(sizeof(Queue));
if (queue == NULL) {
printf("Memory allocation error\n");
exit(EXIT_FAILURE);
}
queue->front = NULL;
queue->rear = NULL;
return queue;
}

void enqueue(Queue* queue, int data) {


Node* newNode = (Node*)malloc(sizeof(Node));
if (newNode == NULL) {
printf("Memory allocation error\n");
exit(EXIT_FAILURE);
}
newNode->data = data;
newNode->next = NULL;
if (queue->rear == NULL) {
queue->front = newNode;
queue->rear = newNode;
} else {
queue->rear->next = newNode;
queue->rear = newNode;
}
}

int dequeue(Queue* queue) {


if (queue->front == NULL) {
printf("Queue is empty. Cannot dequeue.\n");
exit(EXIT_FAILURE);
}
Node* temp = queue->front;
int data = temp->data;
queue->front = queue->front->next;
if (queue->front == NULL) {
queue->rear = NULL;
}
free(temp);
return data;
}

int isEmpty(Queue* queue) {


return (queue->front == NULL);
}
Queue* mergeSortedLists(int A[], int B[], int sizeA, int sizeB) {
Queue* queueA = createQueue();
Queue* queueB = createQueue();
Queue* queueS = createQueue();

// Enqueue elements from list A and B into respective queues


for (int i = 0; i < sizeA; i++)
enqueue(queueA, A[i]);

for (int i = 0; i < sizeB; i++)


enqueue(queueB, B[i]);

while (!isEmpty(queueA) && !isEmpty(queueB)) {


int elementA = dequeue(queueA);
int elementB = dequeue(queueB);

if (elementA <= elementB) {


enqueue(queueS, elementA);
enqueue(queueB, elementB);
} else {
enqueue(queueS, elementB);
enqueue(queueA, elementA);
}
}

while (!isEmpty(queueA))
enqueue(queueS, dequeue(queueA));

while (!isEmpty(queueB))
enqueue(queueS, dequeue(queueB));

return queueS;
}

void printQueue(Queue* queue) {


Node* current = queue->front;
while (current != NULL) {
printf("%d ", current->data);
current = current->next;
}
printf("\n");
}

int main() {
// Input sets
int A1[] = {1, 3, 5, 7, 9};
int B1[] = {2, 3, 6, 8, 10};
int sizeA1 = sizeof(A1) / sizeof(A1[0]);
int sizeB1 = sizeof(B1) / sizeof(B1[0]);

int A2[] = {1, 2, 3, 4, 5};


int B2[] = {6, 7, 8, 9, 10};
int sizeA2 = sizeof(A2) / sizeof(A2[0]);
int sizeB2 = sizeof(B2) / sizeof(B2[0]);

int A3[] = {2, 4, 8, 16, 32};


int B3[] = {1, 3, 5, 7, 9};
int sizeA3 = sizeof(A3) / sizeof(A3[0]);
int sizeB3 = sizeof(B3) / sizeof(B3[0]);

int A4[] = {10, 11, 12, 13};


int B4[] = {1, 2, 3, 4};
int sizeA4 = sizeof(A4) / sizeof(A4[0]);
int sizeB4 = sizeof(B4) / sizeof(B4[0]);

printf("Merging A1 and B1:\n");


Queue* mergedQueue1 = mergeSortedLists(A1, B1, sizeA1, sizeB1);
printQueue(mergedQueue1);

printf("Merging A2 and B2:\n");


Queue* mergedQueue2 = mergeSortedLists(A2, B2, sizeA2, sizeB2);
printQueue(mergedQueue2);

printf("Merging A3 and B3:\n");


Queue* mergedQueue3 = mergeSortedLists(A3, B3, sizeA3, sizeB3);
printQueue(mergedQueue3);

printf("Merging A4 and B4:\n");


Queue* mergedQueue4 = mergeSortedLists(A4, B4, sizeA4, sizeB4);
printQueue(mergedQueue4);

// Free allocated memory


free(mergedQueue1);
free(mergedQueue2);
free(mergedQueue3);
free(mergedQueue4);

return 0;
}

You might also like