Sort a Linked List Using Merge Sort in DSA C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind merge sort when sorting a linked list?

Merge sort divides the linked list into two halves, sorts each half recursively, and then merges the two sorted halves back together.

intermediate

Why is merge sort preferred over quicksort for sorting linked lists?

Merge sort works well with linked lists because it does not require random access and can merge two sorted lists efficiently, while quicksort needs random access which linked lists do not support efficiently.

beginner

How do you find the middle of a linked list efficiently for merge sort?

Use two pointers: a slow pointer that moves one step at a time and a fast pointer that moves two steps at a time. When the fast pointer reaches the end, the slow pointer will be at the middle.

beginner

What is the time complexity of merge sort on a linked list?

The time complexity is O(n log n), where n is the number of nodes in the linked list.

beginner

What is the base case for the recursive merge sort function on a linked list?

The base case is when the linked list is empty or has only one node, which means it is already sorted.

What technique is used to split the linked list into two halves in merge sort?

A Two pointers: slow and fast

B Counting nodes and dividing by two

C Using an array to store nodes

D Randomly splitting the list

Two pointers, slow and fast, are used to find the middle efficiently without counting all nodes.

What is the main operation performed after sorting the two halves in merge sort?

A Swapping nodes randomly

B Deleting duplicates

C Reversing the list

D Merging the two sorted halves

After sorting each half, merge sort merges the two sorted halves into one sorted list.

What is the time complexity of merge sort on a linked list?

A O(n^2)

B O(n)

C O(n log n)

D O(log n)

Merge sort has a time complexity of O(n log n) for linked lists.

Why is merge sort efficient for linked lists compared to quicksort?

A Because merge sort uses random access

B Because merge sort merges lists without random access

C Because quicksort is not recursive

D Because quicksort uses extra memory

Merge sort merges sorted lists efficiently without needing random access, which linked lists do not support well.

What is the base case for the recursive merge sort on a linked list?

A List is empty or has one node

B List has two nodes

C List has more than ten nodes

D List is sorted

The base case is when the list is empty or has only one node, meaning it is already sorted.

Explain step-by-step how merge sort works on a linked list.

Think about dividing the list and combining sorted parts.

Describe why merge sort is a good choice for sorting linked lists compared to other sorting algorithms.

Consider linked list properties and algorithm behavior.

Practice

1. What is the main advantage of using merge sort to sort a linked list compared to quicksort?

easy

A. Merge sort does not require random access, which suits linked lists well.

B. Quicksort uses less memory than merge sort for linked lists.

C. Merge sort is faster than quicksort on arrays.

D. Quicksort is stable while merge sort is not.

Solution

1. Step 1: Understand linked list access

   Linked lists do not support fast random access, unlike arrays.

2. Step 2: Compare sorting algorithms

   Merge sort works well with sequential access, while quicksort relies on random access for efficiency.

3. Final Answer:

   Merge sort does not require random access, which suits linked lists well. -> Option A

4. Quick Check:

   Linked list + merge sort = no random access needed [OK]

Hint: Merge sort fits linked lists due to sequential access [OK]

Common Mistakes:

• Thinking quicksort is always better
• Assuming merge sort needs random access
• Confusing stability of sorting algorithms

2. Which of the following is the correct way to split a linked list into two halves for merge sort in C?

easy

A. Split by dividing the node values by 2.

B. Use two pointers: slow moves 1 step, fast moves 2 steps; slow marks mid.

C. Use a single pointer to count nodes and split at half count.

D. Use recursion without splitting the list.

Solution

1. Step 1: Identify splitting technique

   The fast and slow pointer method finds the middle node efficiently.

2. Step 2: Understand pointer movement

   Slow pointer moves one node at a time, fast pointer moves two nodes; when fast reaches end, slow is at mid.

3. Final Answer:

   Use two pointers: slow moves 1 step, fast moves 2 steps; slow marks mid. -> Option B

4. Quick Check:

   Fast/slow pointers split linked list [OK]

Hint: Use fast/slow pointers to find middle node [OK]

Common Mistakes:

• Trying to split by node values
• Using only one pointer to split
• Not stopping fast pointer correctly

3. Given the linked list: 4 -> 2 -> 1 -> 3 -> NULL, what is the sorted list after applying merge sort?

medium

A. 4 -> 3 -> 2 -> 1 -> NULL

B. 1 -> 3 -> 2 -> 4 -> NULL

C. 2 -> 1 -> 3 -> 4 -> NULL

D. 1 -> 2 -> 3 -> 4 -> NULL

Solution

1. Step 1: Break list into halves recursively

   Split into (4 -> 2) and (1 -> 3), then further split until single nodes.

2. Step 2: Merge sorted halves

   Merge nodes in order: 1, 2, 3, 4 to get sorted list.

3. Final Answer:

   1 -> 2 -> 3 -> 4 -> NULL -> Option D

4. Quick Check:

   Sorted ascending order = 1,2,3,4 [OK]

Hint: Merge sort outputs ascending sorted list [OK]

Common Mistakes:

• Confusing merge order
• Not splitting correctly
• Assuming original order remains

4. In the following C code snippet for merge sort on linked list, what is the error?

Node* mergeSort(Node* head) {
  if (!head || !head->next) return head;
  Node* slow = head;
  Node* fast = head;
  while (fast && fast->next) {
    slow = slow->next;
    fast = fast->next->next;
  }
  Node* mid = slow->next;
  slow->next = NULL;
  Node* left = mergeSort(head);
  Node* right = mergeSort(mid);
  return merge(left, right);
}

medium

A. The base case should check only for head->next, not head.

B. Slow pointer should move two steps each iteration.

C. Fast pointer should start at head->next, not head.

D. The function should not split the list.

Solution

1. Step 1: Analyze pointer initialization

   Fast pointer should start at head->next to correctly find middle for even nodes.

2. Step 2: Understand pointer movement impact

   Starting fast at head skips the first node, causing incorrect mid calculation.

3. Final Answer:

   Fast pointer should start at head->next, not head. -> Option C

4. Quick Check:

   Fast pointer start affects mid node [OK]

Hint: Start fast pointer at head->next for correct mid [OK]

Common Mistakes:

• Starting fast at head
• Moving slow pointer incorrectly
• Ignoring base case conditions

5. You have a linked list with duplicate values: 5 -> 3 -> 8 -> 5 -> 2 -> NULL. After applying merge sort, which of the following is the correct sorted list?

hard

A. 2 -> 3 -> 5 -> 5 -> 8 -> NULL

B. 5 -> 3 -> 8 -> 5 -> 2 -> NULL

C. 2 -> 3 -> 8 -> 5 -> 5 -> NULL

D. 3 -> 2 -> 5 -> 5 -> 8 -> NULL

Solution

1. Step 1: Understand merge sort stability

   Merge sort preserves order of equal elements, so duplicates stay in relative order.

2. Step 2: Sort values ascending

   Sorted order is 2, 3, 5, 5, 8 with duplicates adjacent.

3. Final Answer:

   2 -> 3 -> 5 -> 5 -> 8 -> NULL -> Option A

4. Quick Check:

   Sorted with duplicates preserved = 2,3,5,5,8 [OK]

Hint: Merge sort keeps duplicates in order [OK]

Common Mistakes:

• Assuming duplicates get removed
• Sorting duplicates incorrectly
• Mixing order of duplicates