常用排序算法（C语言描述）

冒泡排序

void BubbleSort(int a[], int n) 
{
    int i, j;
    for (i = 0; i < n; i++) {
        for (j = i+1; j < n; j++) {
            if (a[i] > a[j]) {
                int t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
        }
    }
}

　　

选择排序

void SelectSort(int a[], int n) 
{
    int i, j, min;
    for (i = 0; i < n; i++) {
        min = i;
        for (j = i+1; j < n; j++) {
            if(a[min] > a[j]) {
                min = j;
            }
        }
        if (min != i){ //a[i]这一轮的不是最小值
            int t = a[min];
            a[min] = a[i];
            a[i] = t;
        }
    }
}

　　

　　

插入排序

void InsertSort(int a[], int n) 
{
    int i, j, tmp;
    for (i = 1; i < n; i++) {  //从第2个数开始
        if (a[i] < a[i-1]) {
            tmp = a[i];
            for (j = i; j > 0 && tmp < a[j-1]; j--) {
                a[j] = a[j-1];
            }
            a[j] = tmp;
        }
    }
}

　　

　　

希尔排序

void ShellSort(int a[], int n) 
{
    int gap,i,j;
    for (gap = n/2; gap > 0; gap /=2) {
        //下面是插入排序，只不过间隔是gap，而不是固定值1
        for (i = gap; i < n; i++) {
            if (a[i] < a[i-1]) {
                int tmp = a[i];
                for (j = i; j >= gap && tmp < a[j-gap]; j-=gap) {
                    a[j] = a[j-gap];
                }
                a[j] = tmp;
            }
        }
    }
}

　　

　　

堆排序

#include<iostream>
using namespace std;

//调整为大顶堆
void AdjustHeap(int arr[], int index, int length) {
    int tmp = arr[index];
    for (int i = index*2+1; i < length; i = 2*i+1) {
        //如果一个节点的左孩子存在，并且小于右孩子，那么比较的就是父节点和右孩子
        //否则就是比较父节点和左孩子
        if (i+1 < length && arr[i] < arr[i+1]) {
            i++; 
        }
        if (tmp < arr[i]) {
            //如果左孩子或者右孩子比父节点大，那么就将父节点和大的子节点交换位置
            arr[index] = arr[i];
            index = i;
        } else {
            break;
        }
    }
    arr[index] = tmp;
}

void Sort(int arr[],int length) {
    //构建大顶堆
    for (int i = length/2-1; i >= 0; i--) {
        AdjustHeap(arr, i, length);
    }

    //交换堆顶元素和默认元素之后，再进行调整堆
    for (int i = length-1; i > 0; i--) {
        int t = arr[0];
        arr[0] = arr[i];
        arr[i] = t;

        AdjustHeap(arr, 0, i);
    }
}

int main() {

    int arr[10] = {2,1,4,5,3,7,9,8,0,6};
    Sort(arr, 10);
    for (int i = 0; i < 10; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

 

 

归并排序

void Merge(int a[], int start, int mid, int end, int tmp[])
{
    int s,e,cur,i;
    s = start;
    e = mid+1;
    cur = 0;
    while (s <= mid && e <= end) {
        if (a[s] < a[e]) {
            tmp[cur++] = a[s++];
        } else {
            tmp[cur++] = a[e++];
        }
    }
    while (s <= mid) {
        tmp[cur++] = a[s++];
    }
    while (e <= end) {
        tmp[cur++] = a[e++];
    }
    for (i = 0; i < end-start+1; i++){
        a[start+i] = tmp[i];
    }
}

void MergeSort(int a[], int start, int end,int tmp[])
{
    int mid;
    if (start < end) {
        mid = start + (end - start)/2;
        MergeSort(a, start, mid, tmp);
        MergeSort(a, mid+1, end, tmp);
        Merge(a, start, mid, end, tmp);
    }
}

　　

 

快速排序

#include<stdio.h>

void swap(int a[], int i, int j)
{
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
}

void QuickSort(int a[], int start, int end) 
{
    if(start >= end){
        return;
    }
    int i, j, k;
    i = start;
    j = end;
    k = a[start]; 
    while ( i !=j ) {
        while (i < j && a[j] >= k) {
            j--;
        }
        //找到一个在k的右边，并且比k小的数，所以把他们交换位置，让其在k的左边
        swap(a, i, j);

        while (i < j && a[i] <= k) {
            i++;
        }
        //找到一个在k的左边，并且比k大的数，所以把他们交换位置，让其在k的右边
        swap(a, i, j);
    }
    QuickSort(a, start, i);
    QuickSort(a, i+1, end);
}

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

int main()
{
    int a[10] = {10,5,1,6,3,39,99,21,0,9};
    printArr(a, 10);        
    QuickSort(a, 0, 9);
    printArr(a, 10);        

    return 0;
}

　　

桶排序

 

 

各种排序方式的时间和空间复杂度

 

各种排序方式的使用场景