Quick Sort in C

Quick sort is a commonly used sorting algorithm that is often preferred over other sorting algorithms due to its efficiency and effectiveness. It proceeds by splitting an array into two parts, one with elements smaller than a selected pivot element and the other with elements bigger than the pivot. The algorithm then applies this procedure recursively to each partition until the complete array is sorted.

Quick sort can be used in any scenario where sorting is required, such as in database applications, scientific computing, and web applications. It is frequently utilized when a large dataset must be rapidly and effectively sorted. Some specific use cases where quick sort is commonly used include:

Sorting arrays in programming languages such as C, Java, and Python.
Sorting database records in database management systems.
Sorting large datasets in scientific computing, such as in numerical simulations and data analysis.
Sorting search results in web applications and e-commerce platforms.

Overall, quick sort is a versatile and widely used algorithm that can be applied in a variety of domains where sorting is required. Its low average-case time complexity and simplicity of execution make it an appealing choice for efficiently sorting large datasets.

Here is a C code of quick sort:

C Programming Language:

#include <stdio.h>

// Function to swap two elements
void swap(int* a, int* b) {
	int t = *a;
	*a = *b;
	*b = t;
}
int partition(int arr[], int low, int high) {
	int pivot = arr[high];
	int i = (low - 1);

	for (int j = low; j <= high - 1; j++) {
		if (arr[j] < pivot) {
			i++;
			swap(&arr[i], &arr[j]);
		}
	}
	swap(&arr[i + 1], &arr[high]);
	return (i + 1);
}
void quickSort(int arr[], int low, int high) {
	if (low < high) {
		int pi = partition(arr, low, high);
		quickSort(arr, low, pi - 1);
		quickSort(arr, pi + 1, high);
	}
}

// Function to print the array
void printArray(int arr[], int size) {
	int i;
	for (i = 0; i < size; i++)
		printf("%d ", arr[i]);
	printf("\n");
}

int main() {
	int arr[] = { 12, 17, 6, 25, 1, 5 };
	int n = sizeof(arr) / sizeof(arr[0]);
	quickSort(arr, 0, n - 1);
	printf("Sorted array: \n");
	printArray(arr, n);
	return 0;
}

Output

Sorted array: 
1 5 6 12 17 25

The quick_sort function takes an array arr, and the indices of the first and last elements of the subarray to be sorted, low and high. If low is less than high, the function selects a pivot element using the partition function, and recursively applies the quick_sort function to the two subarrays to the left and right of the pivot.
The partition function takes the same arguments as quick_sort, and returns the index of the pivot element after partitioning the subarray. It begins by selecting the pivot as the last element of the subarray, and initializes an index i to the left of the subarray. It then iterates through the subarray, swapping any element less than the pivot with the element at arr[i] and incrementing i. The centre is then switched for the element at arr[i+1] before returning i+1.
The swap method changes the values of two pointers to integers.
To use this implementation of quick sort, you can simply call quick_sort(arr, 0, n-1), where arr is the array to be sorted and n is its length.
Take note that the pivot in this implementation is the final member of the subarray. This is a simple and commonly used method, but it can lead to poor performance in certain cases, such as when the array is already sorted or nearly sorted. In these situations, efficiency can be enhanced by utilising more sophisticated pivot selection techniques. Additionally, this implementation uses recursion, which can be a source of performance overhead in certain cases. Iterative implementations of quick sort are also possible.

Characteristics:

Quick sort divides an array into two sections according to a pivot element, usually the last element in the array.
All elements smaller than the pivot are put in one partition, and all elements larger than the pivot are placed in the other, dividing the array into two partitions.
The algorithm repeats this procedure for each division until the array as a whole is sorted.
If the data is already ordered or the pivot element is not carefully chosen, quick sort has a worst-case time complexity of O(n2).

Advantages:

Quick sort has a fast average-case time complexity of O(nlogn), making it efficient for large datasets.
It is a simple and easy-to-implement algorithm that can be implemented in a few lines of code.
Quick sort can be easily parallelized, making it suitable for use on multicore and distributed systems.
It is an in-place sorting algorithm, which means that it does not require additional memory to store temporary variables or data structures.

Disadvantages:

Quick sort has a worst-case time complexity of O(n^2) if the pivot element is chosen poorly or the data is already sorted.
It is not a stable sorting algorithm, which means that it does not guarantee the relative order of equal elements in the sorted array.
Quick sort is not suitable for sorting large datasets that do not fit in memory, as it requires multiple passes over the data.

Conclusion:

Quick sort is a popular and efficient sorting algorithm that works by splitting an array into two parts and applying the procedure to each partition recursively until the complete array is sorted. It has an average and best case time complexity of O(nlogn) and a worst-case time complexity of O(n²). Quick sort is frequently favoured over other sorting algorithms due to its simplicity, performance, and ease of implementation, despite its worst-case time complexity.

Next Topicrealloc in C

← prev next →