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;
};

void fun(node* start) {
    if (start == NULL)
        return;
    cout << start->data << "  ";
    
    if (start->next != NULL)
        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