Top MCQs on Linked List Data Structure with Answers

Last Updated :
Discuss
Comments

Question 1

What does the following function do for a given Linked List with first node as head?

C++ 
void fun1(struct node* head) {   if(head == NULL)     return;      fun1(head->next);   printf("%d  ", head->data); }
C 
void fun1(struct node* head) {   if(head == NULL)     return;      fun1(head->next);   printf("%d  ", head->data); }
Java 
void fun1(Node head) {   if(head == null)     return;      fun1(head.next);   System.out.print(head.data + "  "); }
Python 
def fun1(head):   if head is None:     return      fun1(head.next)   print(head.data, end='  ')
JavaScript 
function fun1(head) {   if (head === null)     return;      fun1(head.next);   console.log(head.data + '  '); }


  • Prints all nodes of linked lists

  • Prints all nodes of linked list in reverse order

  • Prints alternate nodes of Linked List

  • Prints alternate nodes in reverse order

Discuss it

Question 2

Which of the following points is/are true about Linked List data structure when it is compared with array?

  • Arrays have better cache locality that can make them better in terms of performance.

  • It is easy to insert and delete elements in Linked List

  • Random access is not allowed in a typical implementation of Linked Lists

  • The size of array has to be pre-decided, linked lists can change their size any time.

  • All of the above

Discuss it

Question 3

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. 

C++ 
void fun(struct node **head_ref) {     struct node *temp = NULL;     struct node *current = *head_ref;      while (current != NULL) {         temp = current->prev;         current->prev = current->next;         current->next = temp;         current = current->prev;     }      if (temp != NULL)         *head_ref = temp->prev; }
C 
void fun(struct node **head_ref) {     struct node *temp = NULL;     struct node *current = *head_ref;      while (current !=  NULL)     {         temp = current->prev;         current->prev = current->next;         current->next = temp;         current = current->prev;     }      if(temp != NULL )         *head_ref = temp->prev; }
Java 
void fun(Node[] head_ref) {     Node temp = null;     Node current = head_ref[0];      while (current != null) {         temp = current.prev;         current.prev = current.next;         current.next = temp;         current = current.prev;     }      if (temp != null)         head_ref[0] = temp.prev; }
Python 
def fun(head_ref):     temp = None     current = head_ref[0]      while current is not None:         temp = current.prev         current.prev = current.next         current.next = temp         current = current.prev      if temp is not None:         head_ref[0] = temp.prev
JavaScript 
function fun(head_ref) {     let temp = null;     let current = head_ref[0];      while (current !== null) {         temp = current.prev;         current.prev = current.next;         current.next = temp;         current = current.prev;     }      if (temp !== null)         head_ref[0] = temp.prev; }

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?

  • 2 <--> 1 <--> 4 <--> 3 <--> 6 <-->5

  • 5 <--> 4 <--> 3 <--> 2 <--> 1 <-->6.

  • 6 <--> 5 <--> 4 <--> 3 <--> 2 <--> 1.

  • 6 <--> 5 <--> 4 <--> 3 <--> 1 <--> 2

Discuss it

Question 4

The following function reverse() is supposed to reverse a singly linked list. There is one line missing at the end of the function. 

C++ 
// Link list node struct node {     int data;     struct node* next; };  // head_ref is a double pointer which points to head (or start) pointer  of linked list static void reverse(struct node** head_ref) {     struct node* prev   = NULL;     struct node* current = *head_ref;     struct node* next;     while (current != NULL)     {         next  = current->next;           current->next = prev;            prev = current;         current = next;     }      // MISSING STATEMENT HERE }
C 
/* Link list node */ struct node {     int data;     struct node* next; };  /* head_ref is a double pointer which points to head (or start) pointer    of linked list */ static void reverse(struct node** head_ref) {     struct node* prev   = NULL;     struct node* current = *head_ref;     struct node* next;     while (current != NULL)     {         next  = current->next;           current->next = prev;            prev = current;         current = next;     }     /*MISSING STATEMENT HERE*/ }
Java 
// Link list node class Node {     int data;     Node next;     Node(int d) { data = d; next = null; } }  // head_ref is a reference to the head pointer of linked list static void reverse(Node[] head_ref) {     Node prev = null;     Node current = head_ref[0];     Node next;     while (current != null) {         next = current.next;         current.next = prev;         prev = current;         current = next;     }     // MISSING STATEMENT HERE }
Python 
# Link list node class Node:     def __init__(self, data):         self.data = data         self.next = None  # head_ref is a reference to the head pointer of linked list def reverse(head_ref):     prev = None     current = head_ref     while current is not None:         next_node = current.next         current.next = prev         prev = current         current = next_node      # MISSING STATEMENT HERE
JavaScript 
// Link list node class Node {     constructor(data) {         this.data = data;         this.next = null;     } }  // head_ref is a reference to the head pointer of linked list function reverse(head_ref) {     let prev = null;     let current = head_ref;     let next;     while (current !== null) {         next = current.next;         current.next = prev;         prev = current;         current = next;     }     // MISSING STATEMENT HERE }

What should be added in place of "/*ADD A STATEMENT HERE*/", so that the function correctly reverses a linked list.

  • Set the value of head_ref to prev;

  • Set the value of head_ref to current;

  • Set the value of head_ref to next;

  • Set the value of head_ref to NULL;

Discuss it

Question 5

What is the output of following function in which start is pointing to the first node of the following linked list 1->2->3->4->5->6 ?

C++ 
#include <iostream> using namespace std;  struct Node {     int data;     Node* next;     Node() { data = 0; next = nullptr; }  };  void fun(Node* start) {     if (start == nullptr)         return;     cout << start->data << "  ";          if (start->next != nullptr)         fun(start->next->next);     cout << start->data << "  "; }
C 
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); }
Java 
class Node {     int data;     Node next;     Node(int d) { data = d; next = null; } }  void fun(Node start) {     if (start == null)         return;     System.out.print(start.data + "  ");          if (start.next != null)         fun(start.next.next);     System.out.print(start.data + "  "); }
Python 
class Node:     def __init__(self, data):         self.data = data         self.next = None   def fun(start):     if start is None:         return     print(start.data, end='  ')          if start.next is not None:         fun(start.next.next)     print(start.data, end='  ')
JavaScript 
class Node {     constructor(data) {         this.data = data;         this.next = null;     } }  function fun(start) {     if (start === null)         return;     console.log(start.data + '  ');          if (start.next !== null)         fun(start.next.next);     console.log(start.data + '  '); }

  • 1 4 6 6 4 1

  • 1 3 5 1 3 5

  • 1 2 3 5

  • 1 3 5 5 3 1

Discuss it

Question 6

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 that contain the correct pseudocode for the blank line. 

C++ 
#include <iostream> struct Node {     int value;     Node *next; };  Node* move_to_front(Node *head) {     Node *p, *q;     if (head == NULL || head->next == NULL)         return head;     q = NULL; p = head;     while (p->next != NULL) {         q = p;         p = p->next;     }     __________________________________     return head; }
C 
typedef struct node  {   int value;   struct node *next; }Node;   Node *move_to_front(Node *head)  {   Node *p, *q;   if ((head == NULL: || (head->next == NULL))      return head;   q = NULL; p = head;   while (p-> next !=NULL)    {     q = p;     p = p->next;   }   _______________________________   return head; }
Java 
class Node {     int value;     Node next;     Node(int value) {         this.value = value;         this.next = null;     } }  Node moveToFront(Node head) {     Node p, q;     if (head == null || head.next == null)         return head;     q = null; p = head;     while (p.next != null) {         q = p;         p = p.next;     }     _____________________________________     return head; }
Python 
class Node:     def __init__(self, value):         self.value = value         self.next = None   def move_to_front(head):     if head is None or head.next is None:         return head     p = head     q = None     while p.next is not None:         q = p         p = p.next     ______________________________     return head
JavaScript 
class Node {     constructor(value) {         this.value = value;         this.next = null;     } }  function moveToFront(head) {     if (head === null || head.next === null)         return head;     let p = head;     let q = null;     while (p.next !== null) {         q = p;         p = p.next;     }    _____________________________     return head; }

  • q = NULL; next of p = head; head = p;

  • next of q = NULL; head = p; next of p = head;

  • head = p; next of p = q; next of q = NULL;

  • next of q = NULL; next of p = head; head = p;

Discuss it

Question 7

The following  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? 

C++ 
class Node { public:     int value;     Node* next; };  void rearrange(Node* list) {     Node* p;     Node* q;     int temp;     if (list == nullptr || list->next == nullptr) {         return;     }     p = list;     q = list->next;     while (q != nullptr) {         temp = p->value;         p->value = q->value;         q->value = temp;         p = q->next;         q = (p != nullptr) ? p->next : nullptr;     } }
C 
struct Node {     int value;     struct Node* next; };  void rearrange(struct Node* list) {     struct Node* p;     struct Node* q;     int temp;     if (list == NULL || list->next == NULL) {         return;     }     p = list;     q = list->next;     while (q != NULL) {         temp = p->value;         p->value = q->value;         q->value = temp;         p = q->next;         q = (p != NULL) ? p->next : NULL;     } }
Java 
class Node {     int value;     Node next; }  void rearrange(Node list) {     Node p, q;     int temp;     if (list == null || list.next == null) {         return;     }     p = list;     q = list.next;     while (q != null) {         temp = p.value;         p.value = q.value;         q.value = temp;         p = q.next;         q = p != null ? p.next : null;     } }
Python 
class Node:     def __init__(self, value):         self.value = value         self.next = None   def rearrange(head):     if head is None or head.next is None:         return     p = head     q = head.next     while q is not None:         p.value, q.value = q.value, p.value         p = q.next         q = p.next if p is not None else None
JavaScript 
class Node {     constructor(value) {         this.value = value;         this.next = null;     } }  function rearrange(list) {     if (list === null || list.next === null) {         return;     }     let p = list;     let q = list.next;     while (q !== null) {         [p.value, q.value] = [q.value, p.value];         p = q.next;         q = p !== null ? p.next : null;     } }

  • 1,2,3,4,5,6,7

  • 2,1,4,3,6,5,7

  • 1,3,2,5,4,7,6

  • 2,3,4,5,6,7,1

Discuss it

Question 8

Suppose each set is represented as a linked list with elements in arbitrary order. Which of the operations among union, intersection, membership, cardinality will be the slowest? (GATE CS 2004)

  • union 

  •  membership

  • cardinality

  •  union, intersection

Discuss it

Question 9

Consider the function f defined below. 

C++ 
#include <iostream>  struct item {     int data;     struct item *next; };  int f(struct item *p) {     return (         (p == NULL) ||          (p->next == NULL) ||          ((p->data <= p->next->data) && f(p->next))     ); }
c 
struct item  {    int data;    struct item * next;  };   int f(struct item *p)  {    return (           (p == NULL) ||            (p->next == NULL) ||            (( p->data <= p->next->data) && f(p->next))          );  }
Java 
class Item {     int data;     Item next;      Item(int data) {         this.data = data;         this.next = null;     } }  public class Main {     public static boolean f(Item p) {         return (             (p == null) ||              (p.next == null) ||              ((p.data <= p.next.data) && f(p.next))         );     } }
Python 
class Item:     def __init__(self, data):         self.data = data         self.next = None   def f(p):     return (         p is None or          p.next is None or          (p.data <= p.next.data and f(p.next))     )
JavaScript 
class Item {     constructor(data) {         this.data = data;         this.next = null;     } }  function f(p) {     return (         p === null ||          p.next === null ||          (p.data <= p.next.data && f(p.next))     ); }

For a given linked list p, the function f returns 1 if and only if (GATE CS 2003)

  • not all elements in the list have the same data value.

  • the elements in the list are sorted in non-decreasing order of data value

  • the elements in the list are sorted in non-increasing order of data value

  • None of them

Discuss it

Question 10

A circularly linked list is used to represent a Queue. A single variable p is used to access the Queue. To which node should p point such that both the operations enQueue and deQueue can be performed in constant time? (GATE 2004) 

  • rear node

  • front node

  • not possible with a single pointer

  • node next to front

Discuss it

There are 39 questions to complete.

Take a part in the ongoing discussion
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy