# Welcome to the Data Structures and Algorithms MCQs Page

Dive deep into the fascinating world of Data Structures and Algorithms with our comprehensive set of Multiple-Choice Questions (MCQs). This page is dedicated to exploring the fundamental concepts and intricacies of Data Structures and Algorithms, a crucial aspect of GATE CSE Exam. In this section, you will encounter a diverse range of MCQs that cover various aspects of Data Structures and Algorithms, from the basic principles to advanced topics. Each question is thoughtfully crafted to challenge your knowledge and deepen your understanding of this critical subcategory within GATE CSE Exam.

Check out the MCQs below to embark on an enriching journey through Data Structures and Algorithms. Test your knowledge, expand your horizons, and solidify your grasp on this vital area of GATE CSE Exam.

Note: Each MCQ comes with multiple answer choices. Select the most appropriate option and test your understanding of Data Structures and Algorithms. You can click on an option to test your knowledge before viewing the solution for a MCQ. Happy learning!

### Data Structures and Algorithms MCQs | Page 1 of 30

Q1.
The recurrence relation capturing the optimal time of the Tower of Hanoi problem with n discs is
Answer: (d).T(n) = 2T(n – 1) + 1
Q2.
Consider a B+-tree in which the maximum number of keys in a node is 5. What is the minimum number of keys in any non-root node?

a.

1

b.

2

c.

3

d.

4

Q3.
What does the following function do for a given Linked List with first node as head?
{
return;

}
Q4.
Which of the following points is/are true about Linked List data structure when it is compared with array
Q5.
Consider the following function that takes reference to head of a Doubly Linked List as parameter. Assume that a node of doubly linked list has previous pointer as prev and next pointer as next.

{
struct node *temp = NULL;

while (current != NULL)
{
temp = current->prev;
current->prev = current->next;
current->next = temp;
current = current->prev;
}

if(temp != NULL )
}

Assume that reference of head of following doubly linked list is passed to above function 1 <--> 2 <--> 3 <--> 4 <--> 5 <-->6. What should be the modified linked list after the function call?
Answer: (c).6 <--> 5 <--> 4 <--> 3 <--> 2 <--> 1
Q6.
Which of the following sorting algorithms can be used to sort a random linked list with minimum time complexity?
Q7.
The following function reverse() is supposed to reverse a singly linked list. There is one line missing at the end of the function.

struct node
{
int data;
struct node* next;
};

/* head_ref is a double pointer which points to head (or start) pointer
{
struct node* prev   = NULL;
struct node* next;
while (current != NULL)
{
next  = current->next;
current->next = prev;
prev = current;
current = next;
}
}

What should be added in place of "/*ADD A STATEMENT HERE*/", so that the function correctly reverses a linked list.
Q8.
What is the output of following function for start pointing to first node of following linked list?
1->2->3->4->5->6

void fun(struct node* start)
{
if(start == NULL)
return;
printf("%d  ", start->data);

if(start->next != NULL )
fun(start->next->next);
printf("%d  ", start->data);
}
Answer: (d).1 3 5 5 3 1
Q9.
The following C function takes a simply-linked list as input argument. It modifies the list by moving the last element to the front of the list and returns the modified list. Some part of the code is left blank. Choose the correct alternative to replace the blank line.
typedef struct node
{
int value;
struct node *next;
}Node;

{
Node *p, *q;
q = NULL; p = head;
while (p-> next !=NULL)
{
q = p;
p = p->next;
}
_______________________________
}
Q10.
The following C function takes a single-linked list of integers as a parameter and rearranges the elements of the list. The function is called with the list containing the integers 1, 2, 3, 4, 5, 6, 7 in the given order. What will be the contents of the list after the function completes execution?

struct node
{
int value;
struct node *next;
};
void rearrange(struct node *list)
{
struct node *p, * q;
int temp;
if ((!list) || !list->next)
return;
p = list;
q = list->next;
while(q)
{
temp = p->value;
p->value = q->value;
q->value = temp;
p = q->next;
q = p?p->next:0;
}
}