Sorting Stability and When to Use Which Sort in DSA C# - Build from Scratch

Sorting Stability and When to Use Which Sort

📖 Scenario: You work in a small bookstore. You have a list of books with their title and year of publication. You want to sort the books by year, but if two books have the same year, you want to keep their original order as they were added to the list.This is important because the order of books with the same year tells you which book arrived first.

🎯 Goal: You will create a list of books, then sort them by year using a stable sorting method so that books with the same year keep their original order.You will also learn when to use stable sorting and when it is okay to use unstable sorting.

📋 What You'll Learn

Create a list of books with exact titles and years

Add a variable to hold the sorting key (year)

Sort the list using a stable sort by year

Print the sorted list showing title and year in order

💡 Why This Matters

🌍 Real World

Sorting lists of items where the order of equal elements matters, such as sorting products by price but keeping the order of arrival.

💼 Career

Understanding sorting stability helps in data processing, UI lists, and anywhere order consistency is important in software development.

1

Create the list of books

Create a list called books of tuples with these exact entries: ("Book A", 2001), ("Book B", 1999), ("Book C", 2001), ("Book D", 2005), ("Book E", 1999)

DSA C#

# Create the list of books with exact titles and years
# Your code here

Hint

Use var books = new List<(string Title, int Year)> { ... } with the exact tuples inside.

2

Add a variable for the sorting key

Create a variable called sortKey that holds a function to get the Year from each book tuple

DSA C#

var books = new List
{
    ("Book A", 2001),
    ("Book B", 1999),
    ("Book C", 2001),
    ("Book D", 2005),
    ("Book E", 1999)
};

// Create sortKey function to get Year from book
# Your code here

Hint

Use a Func delegate with a lambda expression to get the year.

3

Sort the list using stable sort by year

Use books = books.OrderBy(sortKey).ToList() to sort the list by year using a stable sort

DSA C#

var books = new List
{
    ("Book A", 2001),
    ("Book B", 1999),
    ("Book C", 2001),
    ("Book D", 2005),
    ("Book E", 1999)
};

Func sortKey = book => book.Year;

// Sort books by year using stable sort
# Your code here

Hint

Use LINQ OrderBy which is stable and then convert back to list.

4

Print the sorted list

Use a foreach loop with variable book to print each book's title and year in the format Title - Year

DSA C#

var books = new List
{
    ("Book A", 2001),
    ("Book B", 1999),
    ("Book C", 2001),
    ("Book D", 2005),
    ("Book E", 1999)
};

Func sortKey = book => book.Year;

books = books.OrderBy(sortKey).ToList();

// Print each book's title and year in format "Title - Year"
# Your code here

Hint

Use foreach (var book in books) and Console.WriteLine($"{book.Title} - {book.Year}").

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