Comparison Based vs Non Comparison Based Sorting in DSA Go - Build Both Approaches

Comparison Based vs Non Comparison Based Sorting

📖 Scenario: You are working with a list of numbers that need to be sorted. Sometimes, sorting is done by comparing numbers directly. Other times, sorting can be done without comparing numbers, using their properties like digits.

🎯 Goal: You will create a Go program that first sorts a list of numbers using a comparison-based method (Bubble Sort), then sorts the same list using a non-comparison-based method (Counting Sort). You will see how both methods work and their results.

📋 What You'll Learn

Create a slice of integers with exact values

Create a variable for the maximum value in the slice

Implement Bubble Sort to sort the slice using comparisons

Implement Counting Sort to sort the slice without direct comparisons

Print the sorted slices after each sorting method

💡 Why This Matters

🌍 Real World

Sorting is used everywhere: organizing data, searching faster, and making decisions. Knowing different sorting methods helps choose the best one for the task.

💼 Career

Software developers often need to sort data efficiently. Understanding comparison and non-comparison sorting helps in optimizing programs and solving problems faster.

1

Create the initial slice of integers

Create a slice called numbers with these exact integers: 4, 2, 7, 3, 8, 5, 1

DSA Go

# Create the slice called numbers with the given integers
# Your code here

Hint

Use numbers := []int{4, 2, 7, 3, 8, 5, 1} to create the slice.

2

Create a variable for the maximum value

Create a variable called maxVal and set it to 8, which is the maximum value in numbers

DSA Go

package main

func main() {
    numbers := []int{4, 2, 7, 3, 8, 5, 1}
    // Create maxVal variable and set it to 8
    // Your code here
}

Hint

Use maxVal := 8 to store the maximum value.

3

Implement Bubble Sort (Comparison Based Sorting)

Write a nested for loop to perform Bubble Sort on numbers. Use variables i and j for loops. Swap elements if numbers[j] > numbers[j+1].

DSA Go

package main

func main() {
    numbers := []int{4, 2, 7, 3, 8, 5, 1}
    maxVal := 8

    // Implement Bubble Sort below
    // Your code here
}

Hint

Use two loops with i and j. Swap adjacent elements if the left one is bigger.

4

Implement Counting Sort (Non Comparison Based Sorting) and print results

Create a slice called count of size maxVal + 1 initialized with zeros. Count occurrences of each number in numbers. Then overwrite numbers with sorted values using count. Finally, print numbers after Bubble Sort and after Counting Sort.

DSA Go

package main

import "fmt"

func main() {
    numbers := []int{4, 2, 7, 3, 8, 5, 1}
    maxVal := 8

    for i := 0; i  numbers[j+1] {
                numbers[j], numbers[j+1] = numbers[j+1], numbers[j]
            }
        }
    }

    // Implement Counting Sort below and print results
    // Your code here
}

Hint

Use a count slice to store counts. Then rebuild numbers in order. Use fmt.Println to print results.

Practice

1. Which of the following sorting algorithms is non-comparison based?

easy

A. Merge Sort

B. Counting Sort

C. Quick Sort

D. Heap Sort

Solution

1. Step 1: Understand comparison based sorting

   Comparison based sorting algorithms decide order by comparing elements, like Merge Sort, Quick Sort, and Heap Sort.

2. Step 2: Identify non-comparison based sorting

   Counting Sort uses counting and indexing, not direct comparisons, so it is non-comparison based.

3. Final Answer:

   Counting Sort -> Option B

4. Quick Check:

   Counting Sort = Non-comparison based [OK]

Hint: Counting Sort uses counts, not comparisons [OK]

Common Mistakes:

• Confusing Counting Sort with Quick Sort
• Thinking Merge Sort is non-comparison based
• Assuming Heap Sort is non-comparison based

2. Which of the following is the correct syntax to call a non-comparison based sorting function CountingSort(arr []int) in Go?

easy

A. CountingSort{arr}

B. CountingSort arr

C. CountingSort(arr)

D. CountingSort->arr

Solution

1. Step 1: Recall Go function call syntax

   In Go, functions are called with the function name followed by parentheses enclosing arguments.

2. Step 2: Apply syntax to CountingSort

   Calling CountingSort with array arr is done as CountingSort(arr).

3. Final Answer:

   CountingSort(arr) -> Option C

4. Quick Check:

   Function call syntax = CountingSort(arr) [OK]

Hint: Use parentheses for function calls in Go [OK]

Common Mistakes:

• Omitting parentheses in function call
• Using braces {} instead of parentheses
• Using arrow notation which is invalid in Go

3. What will be the output of the following Go code snippet?

arr := []int{4, 2, 7, 1}
CountingSort(arr)
fmt.Println(arr)

Assuming CountingSort sorts the array in ascending order without returning a new array.

medium

A. [1 2 4 7]

B. [4 2 7 1]

C. [7 4 2 1]

D. Compilation error

Solution

1. Step 1: Understand CountingSort behavior

   CountingSort sorts the array in ascending order in-place.

2. Step 2: Apply CountingSort to arr

   Original arr is [4 2 7 1]. After sorting, arr becomes [1 2 4 7].

3. Final Answer:

   [1 2 4 7] -> Option A

4. Quick Check:

   Sorted arr = [1 2 4 7] [OK]

Hint: CountingSort sorts in ascending order in-place [OK]

Common Mistakes:

• Assuming CountingSort returns a new array
• Confusing ascending with descending order
• Thinking code causes compilation error

4. Identify the error in this Go code snippet that attempts to use Radix Sort (a non-comparison based sort):

func RadixSort(arr []int) {
  for i := 0; i < len(arr); i++ {
    // sorting logic here
  }
}

arr := []int{3, 1, 4}
RadixSort(arr)
fmt.Println(arr)

medium

A. Radix Sort requires multiple passes over digits, not just one loop

B. The function should return a new sorted array

C. The loop variable i should start from 1, not 0

D. Radix Sort cannot sort integers

Solution

1. Step 1: Understand Radix Sort process

   Radix Sort sorts numbers digit by digit, requiring multiple passes over digits.

2. Step 2: Analyze given loop

   The code loops only once over array length, missing multiple digit passes needed.

3. Final Answer:

   Radix Sort requires multiple passes over digits, not just one loop -> Option A

4. Quick Check:

   Radix Sort needs multiple digit passes [OK]

Hint: Radix Sort loops over digits, not just array elements [OK]

Common Mistakes:

• Thinking single loop is enough for Radix Sort
• Expecting Radix Sort to return new array always
• Believing Radix Sort cannot sort integers

5. You have an array of 1 million integers ranging only from 0 to 1000. Which sorting approach is best and why?

hard

A. Use Quick Sort because it has average O(n log n) time

B. Use Bubble Sort because it is simple to implement

C. Use Merge Sort because it is stable

D. Use Counting Sort because it sorts in O(n + k) time where k is range

Solution

1. Step 1: Analyze input size and range

   Array size n = 1,000,000; range k = 1001 (0 to 1000).

2. Step 2: Compare sorting complexities

   Counting Sort runs in O(n + k), which is efficient here since k is small compared to n.

3. Step 3: Choose best sorting method

   Counting Sort is faster than Quick Sort's average O(n log n) for this input.

4. Final Answer:

   Use Counting Sort because it sorts in O(n + k) time where k is range -> Option D

5. Quick Check:

   Small range + large n = Counting Sort best [OK]

Hint: Small range large array? Use Counting Sort [OK]

Common Mistakes:

• Choosing Quick Sort ignoring small range advantage
• Preferring Bubble Sort despite poor performance
• Ignoring Counting Sort's linear time for small range