Sorting algorithm and its implementation method in C language
Sorting algorithms are an important part of computer science, and they play a key role in data processing and algorithm design. In C language programming development, mastering different sorting algorithms and their implementation methods is crucial to improving code quality and performance. This article will focus on the discussion of sorting algorithms in C language and introduce several common sorting algorithms and their implementation methods.
1Sorting algorithm and its implementation method in C language
First, let's discuss the insertion sort algorithm. The core idea of the insertion sort algorithm is to insert the elements to be sorted into the sorted part one by one. The specific implementation method is as follows:
void insertionSort(int arr[], int n) {
int i, key, j;
for (i = 1; i < n; i++) {
key = arr[i];
j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}
Next, let’s look at the selection sort algorithm. The selection sort algorithm is a simple and intuitive sorting algorithm. Its basic idea is to select the smallest element from the elements to be sorted each time and place it at the end of the sorted part. The specific implementation method is as follows:
void selectionSort(int arr[], int n) {
int i, j, min_idx;
for (i = 0; i < n-1; i++) {
min_idx = i;
for (j = i + 1; j < n; j++) {
if (arr[j] < arr[min_idx])
min_idx = j;
}
int temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
}
}
Then, we will introduce a commonly used efficient sorting algorithm-quick sort. The quicksort algorithm sorts an array by splitting it into two subarrays, a smaller one and a larger one, and then recursively sorting the subarrays. The specific implementation method is as follows:
int partition(int arr[], int low, int high) {
int pivot = arr[high];
int i = (low - 1);
for (int j = low; j <= 1=“” high-=“”>
if (arr[j] < pivot) {
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
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);
}
}
Finally, we introduce a stable sorting algorithm-merge sort. The merge sort algorithm works by dividing an array into two subarrays, then recursively sorting the subarrays, and finally merging the two sorted subarrays into an ordered array. The specific implementation method is as follows:
void merge(int arr[], int l, int m, int r) {
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1+ j];
i = 0;
j = 0;
k = l;
while (i < n1 && j < n2) {
if (L[i] <= r=“”>
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int l, int r) {
if (l < r) {
int m = l+(r-l)/2;
mergeSort(arr, l, m);
mergeSort(arr, m+1, r);
merge(arr, l, m, r);
}
}
Through the introduction of the above sorting algorithms, we have a preliminary understanding of the sorting algorithms and their implementation methods in C language. Insertion sort, selection sort, quick sort and merge sort are all commonly used sorting algorithms, each with different characteristics and applicable scenarios. In practical applications, we need to choose the most appropriate sorting algorithm according to the specific situation. At the same time, we can further improve the performance of the sorting algorithm through optimization algorithm implementation or parallel computing.
I hope that the introduction in this article can help you better master the sorting algorithm and its implementation method in C language, thereby improving your programming ability and code quality and performance. In actual development, it is very important to reasonably select the sorting algorithm, which will directly affect the execution efficiency of the program. Through in-depth research and practice of algorithms, we can continuously improve our algorithm design and programming capabilities, laying a solid foundation for developing efficient and stable programs.
Part of the code is transferred from: https://www.wodianping.com/c/2023-08/253559.html