Largest and Smallest Number in a Linked List using Recursion Quiz Online Practice Test

Test Name:	Largest and Smallest Number in a Linked List using Recursion Quiz
Subject Category:	Computer Science
Test Type:	Multiple Choice Questions
Total Score / Questions:	10 / 10
Time Allowed:	10 Min
Who Should Practice this Test:	Students, job seekers, or professionals preparing for competitive exams and interviews.

Largest and Smallest Number in a Linked List using Recursion MCQ Quiz Online Practice Test

1. Which approach can be employed to determine the largest and smallest numbers in a linked list?

Recursion

Iteration

Both recursion and iteration

It is not possible to find them

2. Consider the following code snippet for finding the largest element in a linked list:

struct Node {
int val;
struct Node *next;
} *head;
int get_max() {
struct Node* temp = head->next;
int max_num = temp->val;
while(______) {
if(temp->val > max_num)
max_num = temp->val;
temp = temp->next;
}
return max_num;
}
Which line should be inserted to complete the code?

temp->next != 0

temp != 0

head->next != 0

head != 0

3. Consider the following code snippet for finding the smallest element in a linked list:

struct Node {
int val;
struct Node* next;
} *head;
int get_min() {
struct Node* temp = head->next;
int min_num = temp->val;
while(temp != 0) {
if(_________) {
min_num = temp->val;
}
temp = temp->next;
}
return min_num;
}
Which line should be inserted to complete the code?

temp > min_num

val > min_min

temp->val < min_num

temp->val > min_num

4. Analyze the following code snippet to determine its output:

#include <stdio.h>
#include <stdlib.h>
struct Node {
int val;
struct Node* next;
} *head;
int get_max() {
struct Node* temp = head->next;
int max_num = temp->val;
while(temp != 0) {
if(temp->val > max_num)
max_num = temp->val;
temp = head->next; // Mistake here
}
return max_num;
}
int main() {
int n = 9, arr[9] = {5,1,3,4,5,2,3,3,1}, i;
struct Node *temp, *newNode;
head = (struct Node*)malloc(sizeof(struct Node));
head->next = 0;
temp = head;
for(i = 0; i < n; i++) {
newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->next = 0;
newNode->val = arr[i];
temp->next = newNode;
temp = temp->next;
}
int max_num = get_max();
printf("%d", max_num);
return 0;
}
What will be the output of this code?

Runtime error

Garbage value

5. What will be the result of running the following code?

#include <stdio.h>
#include <stdlib.h>

struct Node {
int val;
struct Node* next;
} *head;
int get_max() {
struct Node* temp = head->next;
int max_num = temp->val;
while(temp != 0) {
if(temp->val > max_num)
max_num = temp->val;
temp = temp->next;
}
return max_num;
}
int get_min() {
struct Node* temp = head->next;
int min_num = temp->val;
while(temp != 0) {
if(temp->val < min_num)
min_num = temp->val;
temp = temp->next;
}
return min_num;
}

int main() {
int i, n = 9, arr[9] = {8,3,3,4,5,2,5,6,7};
struct Node *temp, *newNode;
head = (struct Node*)malloc(sizeof(struct Node));
head->next = 0;
temp = head;
for(i = 0; i < n; i++) {
newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->next = 0;
newNode->val = arr[i];
temp->next = newNode;
temp = temp->next;
}
int max_num = get_max();
int min_num = get_min();
printf("%d %d", max_num, min_num);
return 0;
}
What is the output of this code?

2 2

8 8

2 8

8 2

6. What is the time complexity of the following code that finds both the smallest and largest

element in a linked list?
#include <stdio.h>
#include <stdlib.h>
struct Node {
int val;
struct Node* next;
} *head;
int get_max() {
struct Node* temp = head->next;
int max_num = temp->val;
while(temp != NULL) {
if(temp->val > max_num)
max_num = temp->val;
temp = temp->next;
}
return max_num;
}
int get_min() {
struct Node* temp = head->next;
int min_num = temp->val;
while(temp != NULL) {
if(temp->val < min_num)
min_num = temp->val;
temp = temp->next;
}
return min_num;
}
int main() {
int i, n = 9, arr[9] = {8,3,3,4,5,2,5,6,7};
struct Node *temp, *newNode;
head = (struct Node*)malloc(sizeof(struct Node));
head->next = NULL;
temp = head;
for(i = 0; i < n; i++) {
newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->next = NULL;
newNode->val = arr[i];
temp->next = newNode;
temp = temp->next;
}
int max_num = get_max();
int min_num = get_min();
printf("%d %d", max_num, min_num);
return 0;
}
What is the time complexity of this code?

O(1)

O(n)

O(n²)

O(n³)

7. Examine the following recursive function designed to find the maximum value in a linked list:

struct Node {
int val;
struct Node* next;
} *head;
int max_of_two(int a, int b) {
if (a > b)
return a;
return b;
}
int recursive_get_max(struct Node* temp) {
if (temp->next == NULL)
return temp->val;
return max_of_two(______, ________);
}
Which arguments should be used in the max_of_two function to complete the recursive_get_max function?

temp->val,recursive_get_max(temp->next)

temp, temp->next

temp->val, temp->next->val

temp->next->val, temp

8. What will be the result of executing the following code?

#include<stdio.h>
#include<stdlib.h>
struct Node {
int val;
struct Node* next;
} *head;
int max_of_two(int a, int b) {
if (a > b)
return a;
return b;
}
int recursive_get_max(struct Node* temp) {
if (temp->next == NULL)
return temp->val;
return max_of_two(temp->val, recursive_get_max(temp->next));
}

int min_of_two(int a, int b) {
if (a < b)
return a;
return b;
}

int recursive_get_min(struct Node* temp) {
if (temp->next == NULL)
return temp->val;
return min_of_two(temp->val, recursive_get_min(temp->next));
}

int main() {
int n = 9, arr[9] = {1, 3, 2, 4, 5, 0, 5, 6, 7}, i;
struct Node *temp, *newNode;
head = (struct Node*)malloc(sizeof(struct Node));
head->next = NULL;
temp = head;
for (i = 0; i < n; i++) {
newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->next = NULL;
newNode->val = arr[i];
temp->next = newNode;
temp = temp->next;
}
int max_num = recursive_get_max(head->next);
int min_num = recursive_get_min(head->next);
printf("%d %d", max_num, min_num);
return 0;
}
What output will be produced by this code?

7 1

0 7

7 0

1 1

9. What is the time complexity of the following recursive methods for determining the largest and smallest elements in a linked list?

#include<stdio.h>
#include<stdlib.h>
struct Node {
int val;
struct Node* next;
} *head;
int max_of_two(int a, int b) {
if (a > b)
return a;
return b;
}
int recursive_get_max(struct Node* temp) {
if (temp->next == NULL)
return temp->val;
return max_of_two(temp->val, recursive_get_max(temp->next));
}

int min_of_two(int a, int b) {
if (a < b)
return a;
return b;
}

int recursive_get_min(struct Node* temp) {
if (temp->next == NULL)
return temp->val;
return min_of_two(temp->val, recursive_get_min(temp->next));
}

int main() {
int n = 9, arr[9] = {1, 3, 2, 4, 5, 0, 5, 6, 7}, i;
struct Node *temp, *newNode;
head = (struct Node*)malloc(sizeof(struct Node));
head->next = NULL;
temp = head;
for (i = 0; i < n; i++) {
newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->next = NULL;
newNode->val = arr[i];
temp->next = newNode;
temp = temp->next;
}
int max_num = recursive_get_max(head->next);
int min_num = recursive_get_min(head->next);
printf("%d %d", max_num, min_num);
return 0;
}
What is the time complexity of the recursive_get_max and recursive_get_min functions?

O(1)

O(n)

O(n²)

O(n³)

10. What will be the output of the following code?

#include<stdio.h>
#include<stdlib.h>

struct Node {
int val;
struct Node* next;
} *head;

int min_of_two(int a, int b) {
if (a < b)
return a;
return b;
}

int recursive_get_min(struct Node* temp) {
if (temp->next == NULL)
return temp->val;
return min_of_two(temp->val, recursive_get_min(temp->next));
}

int main() {
int n = 5, arr[5] = {1, 1, 1, 1, 1}, i;
struct Node *temp, *newNode;
head = (struct Node*)malloc(sizeof(struct Node));
head->next = NULL;
temp = head;
for (i = 0; i < n; i++) {
newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->next = NULL;
newNode->val = arr[i];
temp->next = newNode;
temp = temp->next;
}
int min_num = recursive_get_min(head->next);
printf("%d", min_num);
return 0;
}
What is the output of this program?

Compile time error

Runtime error