Quick Sort as Divide and Conquer in DSA Go - Build from Scratch

Quick Sort as Divide and Conquer

📖 Scenario: You are helping a small bookstore organize their list of book prices so they can quickly find the cheapest and most expensive books.

🎯 Goal: You will build a program that sorts a list of book prices using the Quick Sort method, which splits the list into smaller parts and sorts each part.

📋 What You'll Learn

Create a slice of integers called prices with the exact values: 45, 23, 89, 12, 67

Create a variable called pivotIndex to help split the list

Write a function called quickSort that sorts the prices slice using the Quick Sort method

Print the sorted prices slice

💡 Why This Matters

🌍 Real World

Sorting prices helps stores quickly find cheapest or most expensive items, improving sales and inventory management.

💼 Career

Understanding Quick Sort is important for software developers working with data processing, search optimization, and performance improvements.

1

Create the list of book prices

Create a slice of integers called prices with these exact values: 45, 23, 89, 12, 67.

DSA Go

# Create the slice prices with the given values
# Your code here

Hint

Use prices := []int{45, 23, 89, 12, 67} to create the slice.

2

Add a pivot index variable

Create a variable called pivotIndex and set it to 0 to help split the list during sorting.

DSA Go

package main

func main() {
    prices := []int{45, 23, 89, 12, 67}
    // Create pivotIndex variable
    // Your code here
}

Hint

Use pivotIndex := 0 to create the variable.

3

Write the Quick Sort function

Write a function called quickSort that takes a slice of integers called arr and sorts it using the Quick Sort method. Use pivotIndex inside the function to help split the list.

DSA Go

package main

func main() {
    prices := []int{45, 23, 89, 12, 67}
    pivotIndex := 0

    // Write quickSort function below
    // Your code here
}

Hint

Use recursion to sort smaller parts. Use pivotIndex := 0 inside the function to pick the pivot.

4

Print the sorted prices

Print the sorted prices slice using fmt.Println(prices).

DSA Go

package main

import "fmt"

func quickSort(arr []int) []int {
    if len(arr) < 2 {
        return arr
    }

    pivotIndex := 0
    pivot := arr[pivotIndex]
    less := []int{}
    greater := []int{}

    for i := 1; i < len(arr); i++ {
        if arr[i] <= pivot {
            less = append(less, arr[i])
        } else {
            greater = append(greater, arr[i])
        }
    }

    sortedLess := quickSort(less)
    sortedGreater := quickSort(greater)

    result := append(sortedLess, pivot)
    result = append(result, sortedGreater...)

    return result
}

func main() {
    prices := []int{45, 23, 89, 12, 67}
    pivotIndex := 0
    prices = quickSort(prices)

    // Print the sorted prices
    // Your code here
}

Hint

Use fmt.Println(prices) to show the sorted list.

Practice

1. What is the main idea behind the Quick Sort algorithm in the divide and conquer approach?

easy

A. Divide the array into smaller parts, sort them, and combine the results

B. Sort the array by repeatedly swapping adjacent elements

C. Use extra memory to merge two sorted arrays

D. Sort the array by selecting the smallest element each time

Solution

1. Step 1: Understand divide and conquer in Quick Sort

   Quick Sort divides the array into parts around a pivot, sorts parts recursively.

2. Step 2: Compare with other sorting methods

   Unlike bubble or selection sort, Quick Sort uses division and conquering subproblems.

3. Final Answer:

   Divide the array into smaller parts, sort them, and combine the results -> Option A

4. Quick Check:

   Divide and conquer = divide, sort, combine [OK]

Hint: Remember: divide, sort parts, then combine [OK]

Common Mistakes:

• Confusing Quick Sort with bubble or selection sort
• Thinking Quick Sort merges arrays like merge sort
• Ignoring the pivot selection step

2. Which of the following is the correct way to declare a partition function header in Go for Quick Sort?

easy

A. func partition(arr []int, low int, high int) int

B. func partition(arr int[], low int, high int) int

C. func partition(arr []int, low, high int) string

D. func partition(arr []int, low int, high int)

Solution

1. Step 1: Check Go syntax for function parameters

   In Go, slices are declared as []int, and multiple parameters can be declared with types.

2. Step 2: Verify return type for partition

   Partition returns an int index, so return type must be int.

3. Final Answer:

   func partition(arr []int, low int, high int) int -> Option A

4. Quick Check:

   Go func syntax with slice and int return = func partition(arr []int, low int, high int) int [OK]

Hint: Go slices use []type, return type must match function purpose [OK]

Common Mistakes:

• Using incorrect array syntax like int[]
• Wrong return type for partition function
• Missing return type in function declaration

3. What will be the output of the following Go code snippet after calling quickSort(arr, 0, len(arr)-1)?

func partition(arr []int, low, high int) int {
    pivot := arr[high]
    i := low - 1
    for j := low; j < high; j++ {
        if arr[j] < pivot {
            i++
            arr[i], arr[j] = arr[j], arr[i]
        }
    }
    arr[i+1], arr[high] = arr[high], arr[i+1]
    return i + 1
}

func quickSort(arr []int, low, high int) {
    if low < high {
        pi := partition(arr, low, high)
        quickSort(arr, low, pi-1)
        quickSort(arr, pi+1, high)
    }
}

func main() {
    arr := []int{4, 2, 7, 1}
    quickSort(arr, 0, len(arr)-1)
    fmt.Println(arr)
}

medium

A. [7 4 2 1]

B. [4 2 7 1]

C. [1 2 4 7]

D. [1 4 2 7]

Solution

1. Step 1: Trace partition and quickSort on array [4, 2, 7, 1]

   Pivot is last element; after partition, smaller elements move left; recursive calls sort subarrays.

2. Step 2: Final sorted array after all recursive calls

   Array becomes [1, 2, 4, 7] after full quick sort completes.

3. Final Answer:

   [1 2 4 7] -> Option C

4. Quick Check:

   Quick Sort sorts array ascending = [1 2 4 7] [OK]

Hint: Quick Sort sorts in place; final array is sorted ascending [OK]

Common Mistakes:

• Assuming array stays unchanged
• Confusing pivot placement
• Ignoring recursive calls

4. Identify the bug in this Go Quick Sort partition function:

func partition(arr []int, low, high int) int {
    pivot := arr[high]
    i := low
    for j := low; j < high; j++ {
        if arr[j] < pivot {
            i++
            arr[i], arr[j] = arr[j], arr[i]
        }
    }
    arr[i+1], arr[high] = arr[high], arr[i+1]
    return i + 1
}

medium

A. Pivot should be arr[high], not arr[low]

B. Loop should start from low, not low + 1

C. Swap after loop should be arr[high], arr[i]

D. Variable i should be initialized to low - 1

Solution

1. Step 1: Analyze initialization of i in partition

   In standard Lomuto partition with pivot at arr[high], i should start at low - 1 to track smaller elements correctly.

2. Step 2: Check loop and swap logic

   Loop and swaps are correct if i starts at low - 1; current i = low causes incorrect partitioning.

3. Final Answer:

   Variable i should be initialized to low - 1 -> Option D

4. Quick Check:

   Correct i start fixes partition logic [OK]

Hint: Initialize i = low - 1 for Lomuto partition with pivot at end [OK]

Common Mistakes:

• Starting i at low causes wrong partition index
• Confusing pivot position with swap indices
• Changing pivot without adjusting i initialization

5. Given an array with many duplicate elements, which modification to Quick Sort helps improve performance and avoid worst-case behavior?

hard

A. Always choose the first element as pivot

B. Use a three-way partitioning to separate less, equal, and greater elements

C. Avoid recursion by using a single loop

D. Sort only the first half of the array

Solution

1. Step 1: Understand problem with duplicates in Quick Sort

   Duplicates cause many equal elements, leading to unbalanced partitions and slow sorting.

2. Step 2: Apply three-way partitioning solution

   Three-way partitioning divides array into less than, equal to, and greater than pivot, improving efficiency.

3. Final Answer:

   Use a three-way partitioning to separate less, equal, and greater elements -> Option B

4. Quick Check:

   Three-way partitioning handles duplicates better [OK]

Hint: Three-way partitioning handles duplicates efficiently [OK]

Common Mistakes:

• Choosing fixed pivot causes worst-case on duplicates
• Trying to avoid recursion breaks divide and conquer
• Sorting only half misses elements