/ Interview Guides / Linked List MCQ

Linked List MCQ

Last Updated: Jan 08, 2024

Share with :

LinkedList is a linear data structure like arrays. In a Linked List each element is actually a separate object linked to the next element using a reference stored in a pointer.

A Linked List is composed of nodes, which are connected to the next node, using memory references or addresses. A Linked List node usually contains 2 properties stored in it. They are:

The value to be stored in the current node.
The reference or address of the next node, or NULL if it is the last node.

Linked Lists are of 2 types usually:

Singly Linked Lists: They are the standard linked list, where the value of the current node and the reference of the next node is only stored. The reference stored in the last node of the list is NULL.
Doubly Linked Lists: This type of linked list stores all the information of the Singly Linked Lists, along with the reference or memory address of the previous node too if it exists, else NULL.

Useful Resources

Linked List MCQs

Implementation of Stacks and Queues.

Implementation of Binary Trees.

Implementation of Data Structures that can simulate Dynamic Arrays.

All of the above.

Create a free personalised study plan Create a FREE custom study plan

Get into your dream companies with expert guidance

Get into your dream companies with expert..

Real-Life Problems

Prep for Target Roles

Custom Plan Duration

Flexible Plans

Create My Plan

O(1)

O(n)

O(n^2)

None of the above

O(n)

O(1)

O(n^2)

None of the above

O(max(n, m)) // n and m are sizes of the list

O(n + m)

O(min(n, m))

None of the above

O(n)

O(1)

O(logn)

None of the above

Learn via our Video Courses

O(n)

O(1)

O(logn)

None of the above

What will be the output of the following code snippet for 1->2->3->4->5?

void solve (ListNode* head) {
    while(head != NULL) {
		cout << head -> data << " ";
		head = head -> next;
	}
}

1 2 3 4 5

5 4 3 2 1

1 3 5 2 4

2 4 1 3 5

Advance your career with Mock Assessments Refine your coding skills with Mock Assessments

Real-world coding challenges for top company interviews

Real-world coding challenges for top companies

Real-Life Problems

Detailed reports

What will be the output of the following code snippet for the list 1->2->3->4->5->6?

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

1 2 3 4 5 6

1 3 5 5 3 1

1 3 5 1 3 5

2 4 6 1 3 5

What will be the value of “sum” after the following code snippet terminates?

void solve(ListNode* root) {
    /*
    The LinkedList is defined as:
    root-> val = value of the node
    root-> next = address of next element from the node 
    The List is 1 -> 2 -> 3 -> 4 -> 5
    */
    int sum = 0;
    while (root != NULL) {
        sum += root -> val;
        root = root -> next;
    }
    cout << sum << endl;
}

Abstract Syntax Tree

Symbol Table

Semantic Stack

Parse Table

Find length, and then traverse to length / 2 th node.

Fast and slow pointer method

Find distance of all nodes, and print middle nodes.

None of the above

Linear Search

Merge Sort

Insertion Sort

Binary Search

Implementing file systems

Chaining in hash tables

Binary Trees implementation

All of the above

O(1)

O(n)

O(n^2)

None of the above

Value of node

Address of next node

Address of the previous node

All of the above

Singly Linked List

Doubly Linked List

Circular Linked List

Array implementation of linked list.

Both of them are not able to access the data at a random position in constant time.

Both of them can add a new node after given node or at the beginning of the list in O(1) time.

Both of them can delete the first node in O(1) time.

All of the above

Insert element at start of linked list.

Insert element at end of linked list.

Find length of linked list.

None of the above.

Detecting cycle in a linked list

Finding intersection of 2 linked lists

Finding middle element of a linked list

All of the above

Merge Sort

Insertion Sort

Quick Sort

All of the above

Merge Sort

Quick Sort

Insertion Sort

None of the above

delete is a keyword.

free is a library function.

Both A and B

None of the above

Random access of elements at a linked list is not possible.

Arrays have better cache locality than linked list.

The size of linked list is dynamic and can be changed as needed.

All of the above

Singly Linked Lists

Circular Linked Lists

Skip List

None of the above

Singly Linked List

Doubly Linked List

Hashed List

Circular Linked List

O(1)

O(n)

O(n^2)

None of the above

Structs

Class

Both A and B

None of the above

O(1)

O(n)

O(1) if we have address of last node of one of the lists

None of the above

ptr=(NODE*)malloc(sizeof(NODE));

ptr=(NODE*)malloc(NODE);

ptr=(NODE*)malloc(sizeof(NODE*));

ptr=(NODE)malloc(sizeof(NODE));

delete keyword

free keyword

calloc

malloc

1 pointer

2 pointer

3 pointer

4 pointer

O(log n)

O(n)

O(1)

None of the above

Singly Linked Lists

Doubly Linked Lists

Circular Linked Lists

None of the above

Linked List

Trees

Stacks

None of the above

Queue

Linked List

Trees

Stack

O(1)

O(n)

O(n^2)

None of the above

Singly Linked List

Doubly Linked List

Circular Linked List

None of the above

O(1)

O(n)

O(logn)

None of the above

O(1)

O(n)

O(logn)

None of the above

Pointer to character

Pointer to integer

Pointer to node

None of the above

Value of current node

Pointer to left child

Pointer to right child

All of the above

44.

What does the following code snippet do?

int solve (ListNode* list) {
    ListNode* fast = list;
	ListNode* slow = list;
	while(fast -> next != NULL && fast -> next -> next != NULL) {
		fast = fast -> next -> next;
		slow = slow -> next;
	}
	return slow -> data;
}

Find middle element in the linked list.

Find last element in the linked list

Find first element in the linked list

None of the above

45.

What does the following code snippet do?

ListNode* solve(ListNode* head) {
        ListNode* prev = NULL;
        if(head == NULL) {
            return head;
        }
        if(head -> next == NULL) {
            return head;
        }
        ListNode* curr = head -> next;
        while(head != NULL) {
            head -> next = prev;
            prev = head;
            head = curr;
            if(curr != NULL) {
                curr = curr -> next;
            }
        }
        return prev;
    }

Returns the original linked list

Returns the linked list after reversing it

Returns a linked list containing elements at odd indices only

None of the above

Deletes the given node from the linked list

Deletes head of the list

Deletes last node of the list

None of the above

47.

What does the following code snippet do?

ListNode* solve(ListNode* head, int x) {
	ListNode* front = head;
	int count = 1;
	while(front != NULL) {
		cout << front -> data << " " << head -> data << endl;
		if(count <= x) {
			front = front -> next;
		}
		else {
			head = head -> next;
			front = front -> next;
		}
		count++;
	}
	return head;
}

Find xth node from beginning of a linked list.

Find xth node from end of a linked list

Find x-1th node from end of a linked list

None of the above

O(n)

O(n ^ 2)

O(n * logn)

None of the above

O(n)

O(n^2)

O(n * log n)

None of the above

O(n)

O(1)

O(log n)

None of the above