Chapter quiz · Linked Lists

Test what you learned.

8 questions on Linked Lists. Pass 70% to clear the chapter.

← Review chapter lessons

Quiz

Linked Lists — Chapter Quiz

Eight questions on singly/doubly/circular lists, reversal, Floyd's cycle detection, and slow/fast pointers.

0/ 9

Question 1
1
What is the time complexity of inserting a node at the head of a singly linked list?
AO(n)BO(log n)CO(1)DO(n²)
Inserting at the head only requires updating the next pointer of the new node and updating the head reference — constant time regardless of list length.
Question 2
2
What key advantage does a doubly linked list have over a singly linked list?
AIt uses less memoryBIt can be traversed in both directions and supports O(1) deletion given a node referenceCIt guarantees O(1) random access by indexDIt is automatically sorted
Each node stores both next and prev pointers. This allows backward traversal and O(1) deletion when you already have the node, because you can reach both neighbours directly. The cost is an extra pointer per node.
Question 3
3
When reversing a singly linked list iteratively, which three variables are typically maintained?
Ahead, tail, sizeBprev, curr, nextCleft, right, midDfast, slow, dummy
You walk the list with curr, saving curr.next in next before overwriting it, then pointing curr.next to prev. After the loop, prev is the new head. O(n) time, O(1) space.
Question 4
4
Floyd's cycle detection (tortoise and hare) works by:
AHashing every visited node and checking for duplicatesBMoving a slow pointer one step and a fast pointer two steps; they meet inside the cycle if one existsCSorting all nodes by address and looking for repeatsDReversing the list and comparing it to the original
If a cycle exists, the fast pointer laps the slow pointer and they meet. If no cycle, the fast pointer reaches null first. O(n) time, O(1) space — no extra storage needed.
Question 5
5
To find the middle node of a linked list in one pass, you should:
ACount all nodes then traverse to n/2BUse a slow pointer (1 step) and a fast pointer (2 steps); when fast reaches the end, slow is at the middleCConvert the list to an array and index into the middleDUse three pointers — left, mid, right
The slow/fast (tortoise/hare) pointer trick: fast advances twice as quickly, so when it can't move further, slow has covered half the list. For even-length lists, slow lands on the second middle node using this variant.
Question 6
6
A circular linked list always has a null tail pointer.
TTrueFFalse
In a circular linked list the last node's next points back to the head, forming a cycle. There is no null terminator.
Question 7
7
When you remove a node from a doubly linked list and you already hold a reference to that node, the operation runs in O(___) time.
With both prev and next pointers available you can redirect node.prev.next and node.next.prev in two assignments — no traversal required.
Question 8
8
Which of the following are situations where a linked list is preferable to a plain JS array? (Select all that apply)
Select all that apply.
AFrequent insertions and deletions at both ends with O(1) guaranteesBImplementing a queue without the O(n) cost of Array.shift()CRandom access by index in O(1)DBuilding an LRU cache where nodes are moved on every access
Linked lists excel at pointer-level splice operations. Doubly linked lists make LRU node movement O(1). Arrays win for index access (O(1) vs O(n) for linked lists).