1. Bubble sort
Bubble sort (English: Bubble Sort) is a simple sorting algorithm. It repeatedly visits the array to be sorted, compares two elements at a time, and swaps them if they are in the wrong order (such as from large to small, with the first letter from A to Z).
Process demo:
code:
#include <stdio.h>
void bubble_sort(int arr[], int len) {
int i, j, temp;
for (i = 0; i < len - 1; i++)
for (j = 0; j < len - 1 - i; j++)
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
int main() {
int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
int len = (int) sizeof(arr) / sizeof(*arr);
bubble_sort(arr, len);
int i;
for (i = 0; i < len; i++)
printf("%d ", arr[i]);
return 0;
}
2. Selection sort
Selection sort is a simple and intuitive sorting algorithm. It works as follows. First find the smallest (largest) element in the unsorted sequence, store it at the beginning of the sorted sequence, then continue to find the smallest (largest) element from the remaining unsorted elements, and then put it at the end of the sorted sequence. And so on until all elements are sorted.
Process demo:
code:
void selection_sort(int a[], int len)
{
int i,j,temp;
for (i = 0 ; i < len - 1 ; i++)
{
int min = i; // 记录最小值，第一个元素默认最小
for (j = i + 1; j < len; j++) // 访问未排序的元素
{
if (a[j] < a[min]) // 找到目前最小值
{
min = j; // 记录最小值
}
}
if(min != i)
{
temp=a[min]; // 交换两个变量
a[min]=a[i];
a[i]=temp;
}
/* swap(&a[min], &a[i]); */ // 使用自定义函数交換
}
}
/*
void swap(int *a,int *b) // 交换两个变量
{
int temp = *a;
*a = *b;
*b = temp;
}
*/
3. Insertion sort
Insertion sort (English: Insertion Sort) is a simple and intuitive sorting algorithm. It works by constructing an ordered sequence, and for unsorted data, scans from the back to the front in the sorted sequence, finds the corresponding position and inserts it. In the implementation of insertion sort, in-place sorting is usually used (that is, the sorting that only needs to use {\displaystyle O(1)} {\displaystyle O(1)} extra space), so in the process of scanning from back to front , it is necessary to repeatedly move the sorted elements backward step by step
Move out of place to provide insertion space for the newest element.
Process demo:
void insertion_sort(int arr[], int len){
int i,j,temp;
for (i=1;i<len;i++){
temp = arr[i];
for (j=i;j>0 && arr[j-1]>temp;j--)
arr[j] = arr[j-1];
arr[j] = temp;
}
}
4. Hill sort
Hill sort, also known as decrement-increment sorting algorithm, is a more efficient and improved version of insertion sort. Hill sort is an unstable sorting algorithm.
Hill sort is an improved method based on the following two properties of insertion sort:
-
Insertion sorting is efficient when operating on almost sorted data, that is, it can achieve the efficiency of linear sorting
-
But insertion sorting is generally inefficient because insertion sorting can only move data one bit at a time
Process demo:
void shell_sort(int arr[], int len) {
int gap, i, j;
int temp;
for (gap = len >> 1; gap > 0; gap = gap >> 1)
for (i = gap; i < len; i++) {
temp = arr[i];
for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap)
arr[j + gap] = arr[j];
arr[j + gap] = temp;
}
}
5. Merge sort
Divide the data into two segments, and move the smallest elements from the two segments to the end of the new data segment one by one.
Can be done top-down or bottom-up.
Process demo:
Iterative method:
int min(int x, int y) {
return x < y ? x : y;
}
void merge_sort(int arr[], int len) {
int* a = arr;
int* b = (int*) malloc(len * sizeof(int));
int seg, start;
for (seg = 1; seg < len; seg += seg) {
for (start = 0; start < len; start += seg + seg) {
int low = start, mid = min(start + seg, len), high = min(start + seg + seg, len);
int k = low;
int start1 = low, end1 = mid;
int start2 = mid, end2 = high;
while (start1 < end1 && start2 < end2)
b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
while (start1 < end1)
b[k++] = a[start1++];
while (start2 < end2)
b[k++] = a[start2++];
}
int* temp = a;
a = b;
b = temp;
}
if (a != arr) {
int i;
for (i = 0; i < len; i++)
b[i] = a[i];
b = a;
}
free(b);
}
Recursive method:
void merge_sort_recursive(int arr[], int reg[], int start, int end) {
if (start >= end)
return;
int len = end - start, mid = (len >> 1) + start;
int start1 = start, end1 = mid;
int start2 = mid + 1, end2 = end;
merge_sort_recursive(arr, reg, start1, end1);
merge_sort_recursive(arr, reg, start2, end2);
int k = start;
while (start1 <= end1 && start2 <= end2)
reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
while (start1 <= end1)
reg[k++] = arr[start1++];
while (start2 <= end2)
reg[k++] = arr[start2++];
for (k = start; k <= end; k++)
arr[k] = reg[k];
}
void merge_sort(int arr[], const int len) {
int reg[len];
merge_sort_recursive(arr, reg, 0, len - 1);
}
Six, quick sort
Randomly select an element in the interval as the benchmark, place the elements smaller than the benchmark before the benchmark, and place the elements greater than the benchmark after the benchmark, and then sort the decimal area and the large number area respectively.
Process demo:
Iterative method:
typedef struct _Range {
int start, end;
} Range;
Range new_Range(int s, int e) {
Range r;
r.start = s;
r.end = e;
return r;
}
void swap(int *x, int *y) {
int t = *x;
*x = *y;
*y = t;
}
void quick_sort(int arr[], const int len) {
if (len <= 0)
return; // 避免len等於負值時引發段錯誤（Segment Fault）
// r[]模擬列表,p為數量,r[p++]為push,r[--p]為pop且取得元素
Range r[len];
int p = 0;
r[p++] = new_Range(0, len - 1);
while (p) {
Range range = r[--p];
if (range.start >= range.end)
continue;
int mid = arr[(range.start + range.end) / 2]; // 選取中間點為基準點
int left = range.start, right = range.end;
do
{
while (arr[left] < mid) ++left; // 檢測基準點左側是否符合要求
while (arr[right] > mid) --right; //檢測基準點右側是否符合要求
if (left <= right)
{
swap(&arr[left],&arr[right]);
left++;right--; // 移動指針以繼續
}
} while (left <= right);
if (range.start < right) r[p++] = new_Range(range.start, right);
if (range.end > left) r[p++] = new_Range(left, range.end);
}
}
Recursive method:
void swap(int *x, int *y) {
int t = *x;
*x = *y;
*y = t;
}
void quick_sort_recursive(int arr[], int start, int end) {
if (start >= end)
return;
int mid = arr[end];
int left = start, right = end - 1;
while (left < right) {
while (arr[left] < mid && left < right)
left++;
while (arr[right] >= mid && left < right)
right--;
swap(&arr[left], &arr[right]);
}
if (arr[left] >= arr[end])
swap(&arr[left], &arr[end]);
else
left++;
if (left)
quick_sort_recursive(arr, start, left - 1);
quick_sort_recursive(arr, left + 1, end);
}
void quick_sort(int arr[], int len) {
quick_sort_recursive(arr, 0, len - 1);
}
There is a sort called Bogo Monkey:
-
1. Check whether it is arranged
-
2. Disrupt
-
3. Check whether it is arranged
-
4. Disrupt
-
5、……
If there is a little more data, it is almost impossible to sort it well.
Sort code:
#include <time.h>
#include <stdlib.h>
#include <stdbool.h>
void swap(int* x, int* y){
//交换
int temporary = *x;
*x = *y;
*y = temporary;
}
void randomize(int arr[], int length){
//打乱数组
for(int i = 0; i < length; i++){
srand(time(NULL)+i);//引入i增加随机性
if(rand()%2) swap(&arr[i],&arr[i+1]);
}
//printf("!");//记录打乱次数
}
bool isSorted(int arr[], int length){
for(int i = 0; i < length; i++) if(arr[i]>=arr[i+1]) return false;
return true;
}
void bogoSort(int array[], int length){
while(!isSorted(array,length)) randomize(array,length);
}Demo：
#include <stdio.h>
int main(){
int numbers[] = {20,9,233,0,-23,7,1,666,4,345,63,45,2,45};
bogoSort(numbers,14);//也可以改成更小
for(int i = 0; i < 14; i++) printf("%d,",numbers[i]);
}