C语言排序算法

数组排序算法

交换排序算法

冒泡排序

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3. 针对所有的元素重复以上的步骤，除了最后一个；
4. 重复步骤1~3，直到排序完成

#include <stdio.h>

main(){
	int arr[10] = {2,3,5,6,4,8,1,0,9,7}; 
	int len = sizeof(arr)/sizeof(arr[0]) ;//求数组长度
	 
	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;
			}
		}
	}
	
	for(i=0;i<len-1;i++){
		printf("%d\n",arr[i]);
	}
	
}

选择排序

1. 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
2. 从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3. 重复第二步，直到所有元素均排序完毕。

#include <stdio.h>

main(){
	int arr[10] = {2,3,5,6,4,8,1,0,9,7}; 
	int len = sizeof(arr)/sizeof(arr[0]) ;//求数组长度
	 
	int i,j,temp;
	
	for (i=0; i <=len-1; i++){
		for(j=i+1; j <=len-1; j++){
			if(arr[i] > arr[j]){
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
	}
	
	for(i=0;i<len-1;i++){
		printf("%d\n",arr[i]);
	}
}

快速排序

一拆为二

1. 从数列中挑出一个元素，称为"基准"（pivot），
2. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3. 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。

#include <stdio.h>

void quick_sort(int arr[], int low, int high) {
    if (low < high) {
        int pivot = partition(arr, low, high);
        quick_sort(arr, low, pivot - 1);
        quick_sort(arr, pivot + 1, high);
    }
}

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 swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    quick_sort(arr, 0, n - 1);
    printf("排序后的数组： ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("");
    return 0;
}

插入排序

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取下一个元素tem，从已排序的元素序列从后往前扫描
3. 如果该元素大于tem，则将该元素移到下一位
4. 重复步骤3，直到找到已排序元素中小于等于tem的元素
5. tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置
6. 重复步骤2~5

#include <stdio.h>

void insertion_sort(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;
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);

    insertion_sort(arr, n);

    printf("排序后的数组：");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("");

    return 0;
}

希尔排序

希尔排序被称为插入排序的改良版

#include <stdio.h>

void shell_sort(int arr[], int n) {
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j;
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
    }
}

int main() {
    int arr[] = {9, 8, 7, 6, 5, 4, 3, 2, 1};
    int n = sizeof(arr) / sizeof(arr[0]);

    shell_sort(arr, n);

    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    return 0;
}