Sorting Stability and When to Use Which Sort in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to perform a sort on the array using built-in methods.

DSA C#

Array.Sort(arr, (a, b) => (a.Value [1] b.Value) ? -1 : (b.Value [1] a.Value) ? 1 : 0);

Drag options to blanks, or click blank then click option'

A<

B>

C==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' causes descending order, which is not the expected ascending order.

Using '==' or '!=' does not define a proper order for sorting.

The comparison uses < to sort in ascending order.

2fill in blank

medium

Complete the code to check if a sorting algorithm is stable by comparing original and sorted lists.

DSA C#

bool isStable = originalList.SequenceEqual(sortedList, [1]);

Drag options to blanks, or click blank then click option'

AReferenceEquals

BEqualityComparer<Item>.Default

CObject.Equals

DComparer<Item>.Default

Attempts:

3 left

💡 Hint

Common Mistakes

Using Comparer<T>.Default compares order, not equality.

ReferenceEquals checks if two references point to the same object, not equality.

EqualityComparer<Item>.Default checks value equality, which helps verify stability.

3fill in blank

hard

Fix the error in the code to perform a stable sort using LINQ.

DSA C#

var stableSorted = list.OrderBy(x => x.Key).[1]();

Drag options to blanks, or click blank then click option'

AOrderByDescending

BSort

CToList

DThenBy

Attempts:

3 left

💡 Hint

Common Mistakes

Using Sort() on IEnumerable causes errors because Sort is a List method.

OrderByDescending changes the order to descending, not stable ascending.

OrderBy returns an IEnumerable; ToList() converts it back to a list preserving order.

4fill in blank

hard

Fill both blanks to create a stable sort by two keys using LINQ.

DSA C#

var sorted = list.OrderBy(x => x.[1]).[2](x => x.Age).ToList();

Drag options to blanks, or click blank then click option'

AName

BThenBy

COrderByDescending

DSort

Attempts:

3 left

💡 Hint

Common Mistakes

Using Sort instead of ThenBy breaks the LINQ chain.

Using OrderByDescending changes the order to descending.

OrderBy sorts by Name first, ThenBy sorts by Age next, preserving stability.

5fill in blank

hard

Fill all three blanks to implement a custom stable sort using List.Sort with a comparer.

DSA C#

list.Sort((x, y) => {
    int result = x.[1].CompareTo(y.[2]);
    if (result == 0) return x.[3].CompareTo(y.[3]);
    return result;
});

Drag options to blanks, or click blank then click option'

AName

BAge

CId

DValue

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing different properties in the first line causes incorrect sorting.

Not comparing a second property causes unstable sort when keys are equal.

Compare first by Name, then by Age if Names are equal to keep sort stable.

Practice

1. What does it mean when a sorting algorithm is called stable?

easy

A. It uses less memory than unstable sorts.

B. It sorts elements in ascending order only.

C. It keeps the original order of equal elements unchanged.

D. It always sorts in place without extra space.

Solution

1. Step 1: Understand stability in sorting

   A stable sort means if two elements are equal, their order stays the same as before sorting.

2. Step 2: Compare with other options

   Options B, C, and D describe other properties but not stability.

3. Final Answer:

   It keeps the original order of equal elements unchanged. -> Option C

4. Quick Check:

   Stable sort = keeps equal elements order [OK]

Hint: Stable means equal items keep their order [OK]

Common Mistakes:

• Confusing stability with sorting order
• Thinking stability means less memory use
• Assuming all sorts are stable

2. Which of the following is the correct C# syntax to call the built-in stable sort method on a list named numbers?

easy

A. Sort(numbers);

B. numbers.Sort();

C. numbers.StableSort();

D. numbers.OrderBy(x => x);

Solution

1. Step 1: Identify the correct method for sorting a List in C#

   The List<T> class has a Sort() method that sorts the list in place and is stable.

2. Step 2: Check other options

   Sort(numbers); is incorrect syntax as Sort is an instance method. numbers.OrderBy(x => x); returns an IEnumerable but does not sort the list in place. numbers.StableSort(); is not a valid method in C#.

3. Final Answer:

   numbers.Sort(); -> Option B

4. Quick Check:

   List.Sort() is correct stable sort call [OK]

Hint: Use List.Sort() to sort in place stably [OK]

Common Mistakes:

• Using LINQ OrderBy without assignment
• Assuming StableSort() exists
• Calling Sort as a standalone function

3. Consider the following C# code snippet:

var items = new List<(int id, string name)> {
  (1, "apple"),
  (2, "banana"),
  (3, "apple"),
  (4, "banana")
};
items = items.OrderBy(item => item.name).ToList();
foreach(var item in items) {
  Console.Write(item.id + " ");
}

What is the output?

medium

A. 1 3 2 4

B. 3 1 2 4

C. 2 4 1 3

D. 4 2 3 1

Solution

1. Step 1: Understand sorting by name with stability

   The list is sorted by the 'name' field. Since OrderBy is stable, equal names keep their original order.

2. Step 2: Trace the sorted order

   Names sorted alphabetically: "apple", "apple", "banana", "banana". Original order for "apple" is id 1 then 3; for "banana" is id 2 then 4.

3. Final Answer:

   1 3 2 4 -> Option A

4. Quick Check:

   Stable sort keeps equal names order: 1 3 2 4 [OK]

Hint: Stable sort keeps original order of equal keys [OK]

Common Mistakes:

• Assuming unstable sort changes order of equal names
• Mixing up id order after sorting
• Ignoring stability property of OrderBy

4. You wrote this code to sort a list of strings by length but it does not keep the original order of equal length strings:

var words = new List<string> { "cat", "dog", "bat", "apple" };
words.Sort((a, b) => a.Length.CompareTo(b.Length));

What is the main reason the original order of equal length strings is not preserved?

medium

A. The Sort method is unstable for custom comparers.

B. The comparison function is incorrect.

C. The list contains duplicates.

D. Strings cannot be sorted by length.

Solution

1. Step 1: Understand stability with custom comparers

   In C#, List.Sort with a custom comparer is not guaranteed to be stable, so equal keys may reorder.

2. Step 2: Check other options

   The comparison function is correct, duplicates do not affect stability, and strings can be sorted by length.

3. Final Answer:

   The Sort method is unstable for custom comparers. -> Option A

4. Quick Check:

   Custom comparer Sort is unstable [OK]

Hint: Custom comparer Sort may be unstable [OK]

Common Mistakes:

• Blaming comparison function for instability
• Thinking duplicates cause instability
• Assuming all Sort calls are stable

5. You have a list of employee records with id and department. You want to sort employees by department alphabetically but keep the original order of employees within the same department. Which sorting approach is best?

hard

A. Use an unstable sort by department for faster sorting.

B. Sort by department descending to keep order.

C. Sort by id first, then sort by department using unstable sort.

D. Use a stable sort by department to keep original order within groups.

Solution

1. Step 1: Identify requirement to keep original order within same department

   This means sorting must be stable so equal departments keep their original order.

2. Step 2: Evaluate options

   Using an unstable sort by department loses original order within groups. Using a stable sort by department preserves it. Sorting by id first then by department with an unstable sort does not guarantee preservation. Sorting descending does not address stability.

3. Final Answer:

   Use a stable sort by department to keep original order within groups. -> Option D

4. Quick Check:

   Stable sort keeps order within equal keys [OK]

Hint: Stable sort preserves order within equal keys [OK]

Common Mistakes:

• Using unstable sort and losing order
• Sorting by id after department breaks order
• Sorting descending does not preserve order