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 list in reverse order

Prints all nodes of linked lists

Prints alternate nodes of Linked List

Prints alternate nodes in reverse order

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

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

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;

Courses
Tutorials
DSA
Data Science
Web Tech

Switch to Dark Mode

Top MCQs on Linked List Data Structure with Answers

Last Updated : Mar 19, 2024

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

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 + '  ');
}

A
Prints all nodes of linked lists
B
Prints all nodes of linked list in reverse order
C
Prints alternate nodes of Linked List
D
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?

A
Arrays have better cache locality that can make them better in terms of performance.
B
It is easy to insert and delete elements in Linked List
C
Random access is not allowed in a typical implementation of Linked Lists
D
The size of array has to be pre-decided, linked lists can change their size any time.
E
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;
}

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?

A
2 <--> 1 <--> 4 <--> 3 <--> 6 <-->5
B
5 <--> 4 <--> 3 <--> 2 <--> 1 <-->6.
C
6 <--> 5 <--> 4 <--> 3 <--> 2 <--> 1.
D
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
}

/* 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.

A
Set the value of head_ref to prev;
B
Set the value of head_ref to current;
C
Set the value of head_ref to next;
D
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 << "  ";
}

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 + '  ');
}

A
1 4 6 6 4 1
B
1 3 5 1 3 5
C
1 2 3 5
D
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;
}

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

A
q = NULL; next of p = head; head = p;
B
next of q = NULL; head = p; next of p = head;
C
head = p; next of p = q; next of q = NULL;
D
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;
    }
}

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

A
1,2,3,4,5,6,7
B
2,1,4,3,6,5,7
C
1,3,2,5,4,7,6
D
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)

A
union
B
membership
C
cardinality
D
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))
    );
}

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)

A
not all elements in the list have the same data value.
B
the elements in the list are sorted in non-decreasing order of data value
C
the elements in the list are sorted in non-increasing order of data value
D
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)

A
rear node
B
front node
C
not possible with a single pointer
D
node next to front

Discuss it

Master DSA and also get 90% fee refund on completing 90% course in 90 days! Take the Three 90 Challenge today.

Step into the Three 90 Challenge – 90 days to push limits, break barriers, and become the best version of yourself! Don't miss your chance to upskill and get 90% refund. What more motivation do you need? Start the challenge right away!

Tags:

DSA Quiz

There are 39 questions to complete.

Take a part in the ongoing discussion