整理的常用的9种排序算法 c语言 复杂度表

#include <stdio.h>

#define Max_ 10      //数组个数

#define RADIX_10 10    //整形排序

#define KEYNUM_31 10     //关键字个数，这里为整形位数

void swap(int *a, int *b)

{

    int temp;

    temp = *a;

    *a = *b;

    *b = temp;

}

// 快速排序

void quick_sort(int s[], int l, int r)

{

    if (l < r)

    {

        //Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1

        int i = l, j = r, x = s[l];

        while (i < j)

        {

            while(i < j && s[j] >= x)  j--;// 从右向左找第一个小于x的数

            

            if(i < j)

                s[i++] = s[j];

            

            while(i < j && s[i] < x)   i++; // 从左向右找第一个大于等于x的数

            if(i < j)

                s[j--] = s[i];

        }

        s[i] = x;

        quick_sort(s, l, i - 1); // 递归调用

        quick_sort(s, i + 1, r);

    }

}

// 冒泡排序

void maopao_sort(int array[],int length){

    for (int i = 0; i < length; i++)

    {

        //每一次由底至上地上升

        for (int j = 0; j < length-i; j++)

        {

            if (array[j] < array[j-1])

            {

                swap(&array[j], &array[j-1]);

            }

        }

    }

}

// 插入排序

void insert_sort(int a[], int len)

{

    int start = 1;//index = 0 的默认排好了的。

    

    //i代表初始吭位置 - 趟数

    for(int i = start; i<len; i++){//设定数组的第一个元素是排序好的

        int j = i;

        int key = a[i];//把s[i]赋给中间变量，相当于把s[i]挖空，等找到合适的元素再把元素插入这个位置

        

        while(j > 0 && a[j-1] > key){// r如果元素比中间值大，则移动位置

            a[j] = a[j-1];

            j--;//不断和排好序的元素比较, 此时的坑index

        }

        

        a[j] = key;//每次循环后把坑填好

    }

}

//希尔，shell 排序

void shell_sort(int a[], int n)

{

    int i, j, gap;

    

    for (gap = n / 2; gap > 0; gap /= 2) //步长

        for (i = 0; i < gap; i++)        //直接插入排序

        {

            for (j = i + gap; j < n; j += gap)

                if (a[j] < a[j - gap])

                {

                    int temp = a[j];

                    int k = j - gap;

                    while (k >= 0 && a[k] > temp)

                    {

                        a[k + gap] = a[k];

                        k -= gap;

                    }

                    a[k + gap] = temp;

                }

        }

}

void Merge(int array[] , int low , int mid , int high)

{

    int i , j , k;

    int *temp = (int *)malloc((high - low + 1)*sizeof(int));

    i = low , j = mid + 1 , k = 0;

    while(i <= mid && j <= high)

    {

        if(array[i] < array[j])        // 进行排序存入动态分配的数组中

            temp[k++] = array[i++];

        else

            temp[k++] = array[j++];

    }

    while(i <= mid)                    // 如果前一半中还有未处理完的数据，按顺序移入动态分配的数组内

        temp[k++] = array[i++];

    while(j <= high)                   // 如果前一半中还有未处理完的数据，按顺序移入动态分配的数组内

        temp[k++] = array[j++];

    for(i = low , j = 0; i<= high ; ++i)

        array[i] = temp[j++];

    

}

//归并排序

void Msort(int array[] , int low , int high)

{

    int mid;

    if(low < high)

    {

        mid = (low + high)>>1;

        Msort(array , low , mid);

        Msort(array , mid + 1 , high);

        Merge(array , low , mid , high);

    }

}

// 堆排序

void HeapAjust(int data[],int i,int length)

{

    int nChild;

    int nTemp;

    for(nTemp=data[i];2*i+1<length;i=nChild)

    {

        nChild=2*i+1;

        if(nChild<length-1&&data[nChild+1]>data[nChild])//比较哪个孩子比自己大，如果是右孩子的话，就要将nChild++；

        {

            nChild++;

        }

        

        if(nTemp<data[nChild])//如果比自己的最大的孩子小，就交换

        {

            data[i]=data[nChild];

            data[nChild]=nTemp;

        }

        else//如果比最大的孩子还大，就不交换

            break;

    }

}

//堆排序

void HeapSort(int data[],int length)

{

    for(int i=(length>>1)-1;i>=0;i--)//注意这个地方：i=(length>>1)-1，加上括号，原因：优先级的问题

    {

        HeapAjust(data,i,length);//初始化一个堆

    }

    for(int j=length-1;j>0;--j)

    {

        int temp=data[j];

        data[j]=data[0];

        data[0]=temp;

        HeapAjust(data,0,j);

    }

}

//直接选择

void select_sort(int a[], int n) {

    for(int i=0; i < n-1; i++) {

        int j = i;

        int min = a[j];

        for(int k=i; k < n; k++) {

            if (a[k] < min) {

                j = k;

                min = a[k];

            }

        }

        int t = a[i];

        a[i] = a[j];

        a[j] = t;

    }

}

//基数排序

int GetNumInPos(int num,int pos)

{

    int temp = 1;

    for (int i = 0; i < pos - 1; i++)

        temp *= 10;

    

    return (num / temp) % 10;

}

//基数排序  pDataArray 无序数组；iDataNum为无序数据个数

void RadixSort(int* pDataArray, int iDataNum)

{

    int *radixArrays[RADIX_10];    //分别为0~9的序列空间

    for (int i = 0; i < 10; i++)

    {

        radixArrays[i] = (int *)malloc(sizeof(int) * (iDataNum + 1));

        radixArrays[i][0] = 0;    //index为0处记录这组数据的个数

    }

    

    for (int pos = 1; pos <= KEYNUM_31; pos++)    //从个位开始到31位

    {

        for (int i = 0; i < iDataNum; i++)    //分配过程

        {

            int num = GetNumInPos(pDataArray[i], pos);

            int index = ++radixArrays[num][0];

            radixArrays[num][index] = pDataArray[i];

        }

        

        for (int i = 0, j =0; i < RADIX_10; i++)    //收集

        {

            for (int k = 1; k <= radixArrays[i][0]; k++)

                pDataArray[j++] = radixArrays[i][k];

            radixArrays[i][0] = 0;    //复位

        }

    }

}

int main(int argc, const char * argv[]) {

    // insert code here...

    int arr_test[Max_] = { 8, 4, 2, 3, 5, 1, 6, 9, 0, 7 };

   // RadixSort( arr_test, Max_);

 

    

 

   

    for(int i=0;i<Max_;i++){

        printf("%d-",arr_test[i]);

    }

    return 0;

}