（C 语言）几大常见的排序（冒泡，选择，快速，插入）

冒泡排序：

#include<stdio.h>
void maopao(int *ret,int retsize)
{
    for (int i = 0; i < retsize - 1; i++)
    {
        for (int j = 1; j < retsize - i; ++j)
        {
            if (ret[j - 1] > ret[j])
            {
                int temp = ret[j];
                ret[j] = ret[j - 1];
                ret[j - 1] = temp;
            }
        }
    }
}
int main()
{
    int a[10] = {10,9,8,7,6,5,4,3,2,1};
    maopao(a,10);
    for(int i = 0;i<sizeof(a)/sizeof(int);i++)
    {
        printf("%d ",a[i]);
    }
    return 0;
}

选择排序：

//
// Created by liujun on 2022/4/26.
//
#include <stdio.h>
//交换元素
void exchange(int *n1,int *n2)
{
    int temp = *n1;
    *n1 = *n2;
    *n2 = temp;
}
//选择排序
void select(int *ret,int retsize)
{
    for(int i = 0;i<retsize-1;i++)
    {
        int minindex = i;
        //找到最小元素的下标
        for (int j = i; j < retsize; ++j)
        {
            if(ret[i] > ret[j])
            {
                minindex = j;
            }
        }
        //交换当前下标元素的值和最小元素下标处的元素的的值
        exchange(&ret[i],&ret[minindex]);
    }
}

int main()
{
    int a[10] = {10,9,8,7,6,5,4,3,2,1};
    select(a,10);
    for(int i = 0;i<sizeof(a)/sizeof(int);i++)
    {
        printf("%d ",a[i]);
    }
    return 0;
}

插入排序：

//
// Created by liujun on 2022/4/26.
//
//插入排序
#include <stdio.h>

void exchange(int *n1,int *n2)
{
    int temp = *n1;
    *n1 = *n2;
    *n2 = temp;
}
//未优化的插入排序
void insert(int *ret,int retsize)
{
    for(int i = 0;i<retsize-1;i++)
    {
        for(int j = i+1;j>0;j--)
        {
            //比较索引j处的值和索引j-1处的值，如果索引j-1处的值比索引j处的大，则交换数据，如果不大，那么就找到合适的位置，退出循环即可
            if(ret[j-1]>ret[j])
            {
                exchange(&ret[j-1],&ret[j]);
            }
            else
            {
                break;
            }
        }
    }

}

//优化后的插入排序
void insert2(int *ret,int retsize)
{
    for(int i = 1;i<retsize;i++)
    {
        for(int j = i-1;j>=0 && ret[j] > ret[j+1];j--)
        {
            exchange(&ret[j],&ret[j+1]);
        }
    }
}

int main()
{
    int a[10] = {10,9,8,7,6,5,4,3,2,1};
    insert2(a,10);
    for(int i = 0;i<sizeof(a)/sizeof(int);i++)
    {
        printf("%d ",a[i]);
    }
}

快速排序（重点:平常中用的比较多的，时间复杂度为O（nlong(n)）):

/
// Created by liujun on 2022/3/17.

#include <stdio.h>
void sort(int *ret,int i,int j)
{
    int temp;
    int left =i,right = j; //规定左右下标
    temp = ret[left]; //以第一个数据为基准值，分割完的数据应该保证左边的数比基准值小，右边的数比基准值大

    while(left<right)
    {
        //先从右边找比temp小的放在左边的空位置上
        while(left<right && temp <=ret[right]) {
            right--; //从右往左看
        }
        /*
        * 当循环结束时left = right，没有找到，即temp最小
        * 当循环结束时left < right ,找到比temp 小的，
        * 把ret[right]放到ret[left]所在的位置
        */
        //此时ret[right]的位置相当于空着的
        if(left<right)
        {
            ret[left] = ret[right];
            left++; //left右移一位
        }
        //接着从左边找比temp大的放到右边的空位
        while(left < right && temp >= ret[left])
        {
            left++;
        }
        if(left < right)
        {
            ret[right]  =ret[left];
            right--;
        }
    }
    //当while结束时分割完成，此时的中间的位置是空的，且left = right
    ret[left] = temp; //将基准值放到中间
    if(i<left)
    {
        sort(ret,i,left-1); //以left-1位新的右边界
    }
    if(left < j)
    {
        sort(ret,left+1,j);//以left+1为新的左边界
    }

}
int main()
{
    int a[10] = {1,1,2,0,2,1,0,0,2,2};
    printf("原始数据：");
    for(int i = 0;i<sizeof(a)/sizeof(int);i++)
    {
        printf("%d ",a[i]);
    }
    printf("\n排序后的数据：");
    sort(a,0,9);
    for(int i = 0;i<sizeof(a)/sizeof(int);i++)
    {
        printf("%d ",a[i]);
    }
    return 0;
}