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

Quick Sort as Divide and Conquer

📖 Scenario: You have a list of numbers that you want to sort from smallest to largest. Sorting helps you find things faster, like organizing books by their height on a shelf.

🎯 Goal: You will build a program that sorts a list of numbers using the Quick Sort method. Quick Sort works by picking a number, then putting smaller numbers to one side and bigger numbers to the other, and repeating this until everything is sorted.

📋 What You'll Learn

Create a vector called numbers with the exact values: 29, 10, 14, 37, 13

Create an integer variable called pivot_index to help with sorting

Write a function called partition that divides the vector around the pivot

Write a function called quickSort that sorts the vector using divide and conquer

Print the sorted vector in the format: 10 -> 13 -> 14 -> 29 -> 37 -> null

💡 Why This Matters

🌍 Real World

Sorting is used everywhere, like organizing files, searching data quickly, or arranging products by price in online stores.

💼 Career

Understanding Quick Sort helps in software development, data analysis, and any job that requires efficient data handling and optimization.

1

Create the initial list of numbers

Create a std::vector<int> called numbers with these exact values: 29, 10, 14, 37, 13

DSA C++

# Create the vector numbers with the given values
// Your code here

Hint

Use std::vector<int> numbers = {29, 10, 14, 37, 13}; to create the list.

2

Add a pivot index variable

Create an integer variable called pivot_index and set it to 0 to help with sorting

DSA C++

#include 
#include 

std::vector numbers = {29, 10, 14, 37, 13};

// Create pivot_index variable
// Your code here

Hint

Write int pivot_index = 0; to create the pivot index.

3

Write the partition and quickSort functions

Write a function called partition that takes std::vector<int>& numbers, int low, and int high and returns an int. It should rearrange elements around the pivot. Then write a function called quickSort that takes std::vector<int>& numbers, int low, and int high and sorts the vector using divide and conquer by calling partition and itself recursively.

DSA C++

#include 
#include 

std::vector numbers = {29, 10, 14, 37, 13};

int pivot_index = 0;

// Write partition function
// Write quickSort function
// Your code here

Hint

Use the last element as pivot in partition. Swap smaller elements to the left. In quickSort, call partition and then call quickSort recursively on left and right parts.

4

Print the sorted vector

Call quickSort on numbers with 0 and numbers.size() - 1 as arguments. Then print the sorted vector in the format: 10 -> 13 -> 14 -> 29 -> 37 -> null

DSA C++

#include 
#include 

std::vector numbers = {29, 10, 14, 37, 13};

int pivot_index = 0;

int partition(std::vector& numbers, int low, int high) {
    int pivot = numbers[high];
    int i = low - 1;
    for (int j = low; j & numbers, int low, int high) {
    if (low < high) {
        int pi = partition(numbers, low, high);
        quickSort(numbers, low, pi - 1);
        quickSort(numbers, pi + 1, high);
    }
}

// Call quickSort and print the sorted vector
// Your code here

Hint

Call quickSort(numbers, 0, numbers.size() - 1); then print each number followed by -> and end with null.

Practice

1. What is the main idea behind the Quick Sort algorithm as a divide and conquer method?

easy

A. Use extra memory to merge two sorted arrays

B. Sort the array by repeatedly swapping adjacent elements

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

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, then sorts each part separately.

2. Step 2: Recognize the sorting and combining process

   After dividing, it sorts the parts recursively and combines them by the nature of recursion.

3. Final Answer:

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

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 Sort
• Thinking Quick Sort uses extra memory like Merge Sort
• Believing Quick Sort selects smallest element each time

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

easy

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

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

C. int partition(int arr, int low, int high);

D. int partition(int arr[], int start, int end, int pivot);

Solution

1. Step 1: Identify correct parameter types

   The partition function takes an array and two indices low and high to work on a subarray.

2. Step 2: Check return type

   Partition returns an integer index where the pivot finally sits.

3. Final Answer:

   int partition(int arr[], int low, int high); -> Option B

4. Quick Check:

   Partition returns int index with arr[], low, high [OK]

Hint: Partition returns pivot index, takes array and two indices [OK]

Common Mistakes:

• Using void return type for partition
• Passing array as int instead of int[]
• Adding extra parameters like pivot unnecessarily

3. What will be the output array after one partition call on arr = [4, 7, 2, 9, 1] with low=0 and high=4 if pivot is chosen as last element?

medium

A. [1, 4, 2, 7, 9]

B. [4, 7, 2, 9, 1]

C. [1, 2, 7, 9, 4]

D. [1, 7, 2, 9, 4]

Solution

1. Step 1: Choose pivot and start partitioning

   Pivot is last element: 1. There are no elements less than 1.

2. Step 2: Rearrange array around pivot

   No swaps occur in the loop since all arr[j] > 1 for j = 0 to 3. Then swap arr[0] and arr[4], resulting in [1, 7, 2, 9, 4].

3. Final Answer:

   [1, 7, 2, 9, 4] -> Option D

4. Quick Check:

   Pivot 1 placed at position 0, all to right > 1 [OK]

Hint: Pivot last element, smaller left, larger right [OK]

Common Mistakes:

• Not moving pivot to correct position
• Swapping elements incorrectly
• Assuming pivot stays at end

4. Identify the error in this Quick Sort partition code snippet:

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

medium

A. Initialization of i should be low - 1

B. Loop should run until j <= high

C. Pivot should be arr[low] instead of arr[high]

D. Swap inside if should be swap(arr[j], arr[i])

Solution

1. Step 1: Check initialization of i

   i should start at low - 1 to track last smaller element index before loop.

2. Step 2: Understand loop and swaps

   Loop runs j from low to high-1 correctly; swapping arr[i+1] and arr[high] places pivot correctly.

3. Final Answer:

   Initialization of i should be low - 1 -> Option A

4. Quick Check:

   i = low - 1 needed for correct partition [OK]

Hint: i starts before low to track smaller elements [OK]

Common Mistakes:

• Starting i at low causes wrong swaps
• Loop running to high causes out-of-bound errors
• Changing pivot position unnecessarily

5. Given an array arr = [10, 80, 30, 90, 40, 50, 70], what is the state of the array after the first full Quick Sort partition step choosing the last element as pivot?

hard

A. [10, 30, 40, 50, 70, 80, 90]

B. [10, 30, 40, 50, 70, 90, 80]

C. [10, 80, 30, 90, 40, 50, 70]

D. [10, 30, 40, 50, 80, 90, 70]

Solution

1. Step 1: Identify pivot and partition

   Pivot is last element 70. Partition rearranges elements less than 70 to left.

2. Step 2: Rearrange array after partition

   Elements less than 70: 10, 30, 40, 50. Elements greater: 80, 90. After partition, pivot 70 placed after smaller elements: [10, 30, 40, 50, 70, 80, 90]

3. Final Answer:

   [10, 30, 40, 50, 70, 80, 90] -> Option A

4. Quick Check:

   Pivot 70 placed after smaller elements [OK]

Hint: Pivot last, smaller left, pivot placed next, larger right [OK]

Common Mistakes:

• Sorting entire array in first step
• Swapping pivot with wrong element
• Assuming pivot moves to last position