Experiment No.

Aim: Implementation of Quick sort using divide and conquer approach.

Required Software/ Software Tool

- Windows Operating System
-C/C++

Theory:
Quick sort is a highly efficient sorting algorithm and is based on partitioning an array of data
into smaller arrays. A large array is partitioned into two arrays one of which holds values
smaller than the specified value, say pivot, based on which the partition is made and another
array holds values greater than the pivot value. Quick sort partitions an array and then calls
itself recursively twice to sort the two resulting sub arrays. This algorithm is quite efficient for
large-sized data sets as its average and worst case complexity are of Ο(n2), where n is the
number of items.

Partition in Quick Sort

Following animated representation explains how to find the pivot value in an array.

The pivot value divides the list into two parts. And recursively, we find the pivot for each
sub- list until all lists contains only one element.
Algorithm:
Based on our understanding of partitioning in quick sort, we will now try to write an
algorithm for it, which is as follows.
Step 1 − Choose the highest index value has pivot
Step 2 − Take two variables to point left and right of the list excluding pivot
Step 3 − left points to the low index
Step 4 − right points to the high
Step 5 − while value at left is less than pivot move right
Step 6 − while value at right is greater than pivot move left
Step 7 − if both step 5 and step 6 does not match swap left and right
Step 8 − if left ≥ right, the point where they met is new pivot

Implementing the Solution Writing Source Code:

#include <iostream>
#include <vector>
//Rajas Karandikar
using namespace std;
// Function to partition the array and return the pivot index
int partition(vector<int>& arr, int low, int high) {
int pivot = arr[high]; // Choose the last element as pivot
int i = low - 1; // Index of the smaller element

for (int j = low; j < high; j++) {

// If current element is smaller than or equal to pivot
if (arr[j] <= pivot) {
i++; // Increment index of smaller element
swap(arr[i], arr[j]);
}
}
swap(arr[i + 1], arr[high]);
return i + 1;
}
// Function to perform Quick Sort
void quickSort(vector<int>& arr, int low, int high) {
if (low < high) {
// Partition the array
int pivotIndex = partition(arr, low, high);

// Recursively sort elements before and after partition

quickSort(arr, low, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, high);
}
}
// Function to print the array
void printArray(const vector<int>& arr) {
for (int num : arr) {
cout << num << " ";
}
cout << endl;
}
int main() {
vector<int> arr = {12, 7, 11, 13, 5, 6};
int n = arr.size();

cout << "Original array: ";

printArray(arr);
 // Perform Quick Sort
quickSort(arr, 0, n - 1);

cout << "Sorted array: ";

printArray(arr);

return 0;
}

Input and Output

Conclusion: Hence we implemented Quick Sort Algorithm using C++.