Quick sort (C language)

There are many sorts , For example, Hill sort , Bubble sort , Heap sort … … There are many kinds of , Today I want to talk about the Quicksort with the lowest time complexity .
First, let's learn about the manual process of quick sorting ：

With the understanding of this manual process , The code is ready , We can write an exchange function first ：

void swapOnce(int *array, int start, int end) {
    
	int i = start;
	int j = end;
	int temp = array[i];

	if (i >= j) {
    
		return;
	}

	while (i < j) {
    
		while (i < j && array[j] > temp) {
    
			j--;
		}
		if (i < j) {
    
			array[i++] = array[j];
		}

		while (i < j && array[i] < temp) {
    
			i++;
		} 
		if (i < j) {
    
			array[j--] = array[i];
		}
	}

	array[i] = temp;

	swapOnce(array, start, i - 1);
	swapOnce(array, i + 1, end);
}

The last two lines of this exchange function are actually the idea of recursion , Because after the first overall exchange , that temp In fact, the whole array is divided into two sub arrays , The work to be done in the two sub arrays is actually the same as that of this large array , So just call this exchange function again .
The following is the array generation and the complete code of this quick sort ：

#include <stdio.h>
#include <malloc.h>
#include <time.h>

int *creatArray(int minValue, int maxValue, int count);
void showArray(int *array, int count);
void swapOnce(int *array, int start, int end);
void quickSort(int *array, int count);

void quickSort(int *array, int count) {
    
	swapOnce(array, 0, count-1);
}

void swapOnce(int *array, int start, int end) {
    
	int i = start;
	int j = end;
	int temp = array[i];

	if (i >= j) {
    
		return;
	}

	while (i < j) {
    
		while (i < j && array[j] > temp) {
    
			j--;
		}
		if (i < j) {
    
			array[i++] = array[j];
		}

		while (i < j && array[i] < temp) {
    
			i++;
		} 
		if (i < j) {
    
			array[j--] = array[i];
		}
	}

	array[i] = temp;

	swapOnce(array, start, i - 1);
	swapOnce(array, i + 1, end);
}

void showArray(int *array, int count) {
    
	int index;

	for(index = 0; index < count; index++) {
    
		printf("[%d] ",array[index]);
	}

	printf("\n");
}

int *creatArray(int minValue, int maxValue, int count) {
    
	int index;
	int value;
	int *array;

	srand(time(0));
	array = (int *) calloc(sizeof(int), count);
	for (index = 0; index < count; index++) {
    
		value = rand() % (maxValue - minValue + 1) + minValue;
		array[index] = value;
	}

	return array;
}

int main() {
    
	int *array = NULL;
	int maxValue;
	int minValue;
	int count;
	
	printf("please input minValue/maxValue/count:"); 
	scanf("%d%d%d", &minValue, &maxValue, &count);
	array = creatArray(minValue, maxValue, count);
	
	printf("before sorting:\n");
	showArray(array, count);
	
	printf("after sorting:\n");
	quickSort(array, count);
	showArray(array, count);
	
	free(array);

	return 0;
}

Let's take a look at the running result of this function ：

If you generate a function for the array in this code , Or if you have any questions about this code, you can leave a message below , Or believe me .