十大排序方法（浅总结一下）

//冒泡排序
void BubbleSort( int n){
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n-i-1; j++){
            if(arr[j + 1] < arr[j]){
                int temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

//选择排序1
void SelectSort_1( int n){
    for (int i = 0; i < n; ++i)
    {
        for (int j = i; j < n; ++j)
        {
            if(arr[i] > arr[j]){
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

//选择排序2
void SelectSort_2( int n){
    for (int i = 0; i < n; i++)
    {
        int k = i;
        for (int j = i + 1 ; j < n; j++)
        {
            if(arr[j] < arr[k]){
                k = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[k];
        arr[k] = temp;
    }
}

//快速排序
void QuickSort(int left, int right){
    int i = left;
    int j = right;
    int mid = arr[(left+right)/2];
    while(i <= j){
        while(arr[i] < mid) i++;
        while(arr[j] > mid) j--;
        if(i <= j){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }
    if(i < right) QuickSort(i, right);
    if(j > left) QuickSort(left, j);
}

//插入排序
void InsertSort(int n){
    int preIndex, curData;
 
    for(int i = 1; i < n; i++){
        preIndex = i - 1;
        curData = arr[i];
        while(preIndex >= 0 && arr[preIndex] > curData){
            arr[preIndex + 1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex + 1] = curData;
    }
}

//局限的归并排序
 
void Merge(int fBegin, int fEnd, int sBegin, int sEnd, int newarr[]){
    for(int i = 0; i < 10; i++){
        printf("%d", arr[i]);
    }
    printf("\n");
    int index = fBegin;
    int f = fBegin;
    int s = sBegin;
    while(f <= fEnd && s <= sEnd){
        if(arr[f] <= arr[s]){
            newarr[index++] = arr[f++];
        }else{
            newarr[index++] = arr[s++];
        }
    }
    while(f <= fEnd){
        newarr[index++] = arr[f++];
    }
    while(s <= sEnd){
        newarr[index++] = arr[s++];
    }
    memcpy(arr + fBegin, newarr + fBegin, sizeof(int) *(sEnd - fBegin + 1));
}
// void Mergetest(){
//     int result[10];
//     Merge(0, 4, 5, 9,result);
//     for(int i = 0; i < 10; i++){
//         printf("%d", result[i]);
//     }
//     printf("\n");
// }
void mergeSort(int left, int right, int newarr[]){
    if(left >= right)
        return;
    int mid = (left + right) / 2;
    mergeSort(left, mid, newarr);
    mergeSort(mid + 1, right, newarr);
    Merge(left, mid, mid+1, right, newarr);
}
void MergeSort(int n){
    int *temp = (int *)malloc(sizeof(int) *n);
    if(temp == NULL){
        return;
    }
    mergeSort(0, n-1, temp);
    free(temp);
}

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

 

//计数排序
 
void CountSort(int n){
    int i, j, k;
    int count[100] = {0};
    for(i = 0; i < n; i++)
    {
        count[arr[i]]++;
    }
 
    k=0;
    for(i = 0; i < 100; i++)
    {
        for(j = 0; j < count[i]; j++)
        {
            arr[k++] = i;
        }
    }
}

//桶排序
void BucketSort(int n)
{
    int max = 0;
    for (int i = 0; i < n; ++i)
    {
        if(max < arr[i])
        {
            max = arr[i];
        }
    }
    int buckets[max];
    memset(buckets, 0, max * sizeof(int));
    for (int i = 0; i < n; ++i)
    {
        buckets[arr[i]]++;
    }
    for (int i = 0, j = 0; i < max; ++i)
    {
        while((buckets[i]--)>0)
            arr[j++] = i;
    }
}

//堆排序
void Heapify(int start, int end)
{
    int dad = start ;
    int son = dad * 2 +1;
    while(son <= end)
    {
        if((son + 1 < end) && (arr[son] < arr[son + 1]))
            son++;
        if(arr[dad] > arr[son])
            return;
        int temp = arr[dad];
        arr[dad] = arr[son];
        arr[son] = temp;
        dad = son;
        son = dad * 2 +1;
    }
}
 
void HeapSort(int n)
{
    int i;
    for (i = (n-1) / 2; i >=0; i--)
    {
        Heapify(i, n-1);
    }
    for (i = n - 1; i > 0; i--)
    {
        int temp = arr[i];
        arr[i]  = arr[0];
        arr[0] = temp;
        Heapify(0, i - 1);
    }
}

作者：鱿余
链接：https://www.nowcoder.com/discuss/1002657
来源：牛客网

//基数排序
 
void _RadixSort(int n;int exp)
{
    int i;
    int result[n];
    int buckets[10] = {0};
    for(i = 0; i < len; i++)
    {
        buckets[(arr[i] / exp) % 10]++;
    }
    for(i = 0; i < 10; i++)
    {
        buckets[i] = buckets[i] + buckets[i-1];
    }
    for(i = len-1; i > 0; i--)
    {
        int iexp = (arr[i] / exp) % 10;
        result[buckets[iexp] - 1] = arr[i];
        buckets[iexp]--;
    }
    memcpy(arr, result, len*sizeof(int));
}
void RadixSort(int n)
{     
    int imax = RadioMax(n);
    int iexp;     
    for(iexp = 1; imax / iexp > 0; iexp = iexp*10){         
        _RadixSort(len, iexp);         
        int y;         
        printf("exp = %-5d ", iexp);         
        for(y = 0; yy < len; y++)             
            printf("%2d", arr[y]);         
        printf("\n");     
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
int arr[100];
int n;
 
int main(int argc, char const *argv[])
{
    printf("请输入元素个数： ");
    scanf("%d", &n);
    printf("请输入元素：\n");
    for(int i = 0; i < n; i++){
        scanf("%d", &arr[i]);
    }
 
    // BubbleSort(n);
 
    // SelectSort_1(n);
 
    // SelectSort_2(n);
 
    // QuickSort(0, n-1);
 
    // InsertSort(n);
     
    // Mergetest();
 
    // MergeSort(n);
 
    // ShellSort(n);
 
    // CountSort(n);
 
    // BucketSort(n);
 
    //HeapSort(10);
 
    printf("排序后：\n");
    for(int i = 0; i < n; i++){
        printf("%-2d", *(arr+i));
    }
    return 0;
}