首页手记 C语言常用排序算法集合
C语言常用排序算法集合

标签：
C 数据结构
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <math.h>
//选择排序
long selectSort(int* arr, int length)
{
    struct timeval time1, time2;
    gettimeofday(&time1, NULL);
    for (int i = 0; i < length - 1; i++)
    {
        for (int j = i + 1; j < length; j++)
        {
            if (arr[i] > arr[j])
            {
                arr[i] = arr[i] ^ arr[j];
                arr[j] = arr[i] ^ arr[j];
                arr[i] = arr[i] ^ arr[j];
            }
        }
    }
    gettimeofday(&time2, NULL);
    return time2.tv_sec - time1.tv_sec;
}
//插入排序
long insertSort(int* arr, int length)
{
    struct timeval time1, time2;
    gettimeofday(&time1, NULL);
    for (int i = 1; i < length; i++)
    {
        if (arr[i] < arr[i - 1])
        {
            for (int j = 0; j < i; j++)
            {
                if (arr[i] < arr[j])
                {
                    arr[i] = arr[i] ^ arr[j];
                    arr[j] = arr[i] ^ arr[j];
                    arr[i] = arr[i] ^ arr[j];
                }
            }
        }
    }
    gettimeofday(&time2, NULL);
    return time2.tv_sec - time1.tv_sec;
}
//折半插入排序
long binaryInsertSort(int* arr, int length)
{
    struct timeval time1, time2;
    gettimeofday(&time1, NULL);
    int head, tail, mid;
    for (int i = 1; i < length; i++)
    {
        if (arr[i] < arr[i - 1])
        {
            head = 0;
            tail = i - 1;
            while (head <= tail)
            {
                mid = (head + tail) / 2;
                if (arr[i] < arr[mid])
                {
                    tail = mid - 1;
                    continue;
                }
                if (arr[i] > arr[mid])
                {
                    head = mid + 1;
                }
                if (arr[i] == arr[mid])
                {
                    head = mid;
                    break;
                }
            }
            for (int k = i; k > head; k--)
            {
                arr[k] = arr[k] ^ arr[k - 1];
                arr[k - 1] = arr[k] ^ arr[k - 1];
                arr[k] = arr[k] ^ arr[k - 1];
            }
        }
    }
    gettimeofday(&time2, NULL);
    return time2.tv_sec - time1.tv_sec;
}
//希尔排序内部替换
void shellReplace(int* arr, int length, int interval)
{
    int i = 0, j;
    while (i + interval <= length - 1)
    {
        if (arr[i] > arr[i + interval])
        {
            arr[i] = arr[i] ^ arr[i + interval];
            arr[i + interval] = arr[i] ^ arr[i + interval];
            arr[i] = arr[i] ^ arr[i + interval];
            j = i;
            while (j - interval >= 0)
            {
                if (arr[j] < arr[j - interval])
                {
                    arr[j] = arr[j] ^ arr[j - interval];
                    arr[j - interval] = arr[j] ^ arr[j - interval];
                    arr[j] = arr[j] ^ arr[j - interval];
                    j -= interval;
                }
                else
                {
                    break;
                }
            }
        }
        i++;
    }
}
//希尔排序
long shellSort(int* arr, int length)
{
    struct timeval time1, time2;
    gettimeofday(&time1, NULL);
    int interval = length >> 1;
    while (interval > 0)
    {
        shellReplace(arr, length, interval);
        interval >>= 1;
    }
    gettimeofday(&time2, NULL);
    return time2.tv_sec - time1.tv_sec;
}
void quickSortDetail(int* arr, int start, int end)
{
    if (start < end)
    {
        int left = start;
        int right = end;
        int store = arr[end];
        while (left < right)
        {
            while (arr[left] <= store && left != right)
            {
                left++;
            }
            if (left != right)
            {
                arr[right] = arr[left];
            }
            while (arr[right] > store && left != right)
            {
                right--;
            }
            if (left != right)
            {
                arr[left] = arr[right];
            }
        }
        arr[left] = store;
        quickSortDetail(arr, start, left - 1);
        quickSortDetail(arr, left + 1, end);
    }
}
//快速排序
long quickSort(int* arr, int length)
{
    struct timeval time1, time2;
    gettimeofday(&time1, NULL);
    quickSortDetail(arr, 0, length - 1);
    gettimeofday(&time2, NULL);
    return time2.tv_sec - time1.tv_sec;
}
//冒泡排序
long bubbleSort(int* arr, int length)
{
    struct timeval time1, time2;
    gettimeofday(&time1, NULL);
    for (int i = length - 1; i > 0; i--)
    {
        for (int j = 0; j < i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                arr[j] = arr[j] ^ arr[j + 1];
                arr[j + 1] = arr[j] ^ arr[j + 1];
                arr[j] = arr[j] ^ arr[j + 1];
            }
        }
    }
    gettimeofday(&time2, NULL);
    return time2.tv_sec - time1.tv_sec;
}
void buildHeap(int* arr, int end)
{
    struct timeval time1, time2;
    gettimeofday(&time1, NULL);
    int nodeChild = end >> 1;
    int* max;
    for (int i = nodeChild - 1; i >= 0; i--)
    {
        if ((i << 1) + 2 >= end)
        {
            if (arr[(i << 1) + 1] > arr[i])
            {
                arr[i] = arr[i] ^ arr[(i << 1) + 1];
                arr[(i << 1) + 1] = arr[i] ^ arr[(i << 1) + 1];
                arr[i] = arr[i] ^ arr[(i << 1) + 1];
            }
        }
        else
        {
            max = arr[(i << 1) + 1] > arr[(i << 1) + 2] ? &arr[(i << 1) + 1] : &arr[(i << 1) + 2];
            if (*max > arr[i])
            {
                arr[i] = arr[i] ^ *max;
                *max = arr[i] ^ *max;
                arr[i] = arr[i] ^ *max;
            }
        }
    }
}
//堆排序
long heapSort(int* arr, int length)
{
    struct timeval time1, time2;
    gettimeofday(&time1, NULL);
    int i = length;
    while (i > 1)
    {
        buildHeap(arr, i);
        arr[0] = arr[0] ^ arr[i - 1];
        arr[i - 1] = arr[0] ^ arr[i - 1];
        arr[0] = arr[0] ^ arr[i - 1];
        i--;
    }
    gettimeofday(&time2, NULL);
    return time2.tv_sec - time1.tv_sec;
}
//归并排序(由于该算法比较复杂，将详细注释)
long mergerSort(int* arr, int length)
{
    //定义时间结构体
    struct timeval time1, time2;
    //获取当前时间
    gettimeofday(&time1, NULL);
    //申请一块与待排序的数组相同大小的空间
    int* copy = (int*)malloc(sizeof(int) * length);
    //定义原数组和新建数组交换标识变量，默认从原数组开始
    int isArr = 1;
    //定义每一组的元素个数，之所以为double是为了下面的ceil函数做准备
    double groupNum = 1;
    //定义变量，i为循环变量，start为跟随数组索引变量，index为每一次数组复制时的位置记录变量，
    // groupA是分组一的索引记录变量
    //groupB为分组二的索引记录变量，groupBinary表示有几对分组进行归并
    int i, start, index, groupA, groupB, groupBinary;
    //groupCount计算出分组的数量
    int groupCount = (int)ceil(length / groupNum);
    //判断，当分组数量大于1时进行循环，为1时也自然就不用循环了，因为都已经排好序了
    while (groupCount > 1)
    {
        //计算出分组对数
        groupBinary = groupCount / 2;
        //赋start为0
        start = 0;
        //赋index为0
        index = 0;
        //总共肯定只能进行groupBinary对分组的归并，分布上组的肯定也只有一个，放在下一次的比较中
        for (i = 0; i < groupBinary; i ++)
        {
            //每一对分组归并，从数组的start位置开始
            groupA = start;
            //这一对分组中的第二组从start位置偏移groupNum个位置开始，因为每一对分组总是组里元素数量的两倍
            groupB = start + (int)groupNum;
            //循环对一对分组进行归并，原理是，那个小，那个先往待放入数组走
            while (groupA < start + groupNum && groupB < start + 2 * groupNum && groupB < length)
            {
                //由于是两个数组交替赋值，所以isArr就是区分它们的
                if (isArr == 1)
                {
                    //如果第一组比后一组的元素小，则优先进入，因为是升序排列嘛
                    if (arr[groupA] < arr[groupB])
                    {
                        copy[index] = arr[groupA];
                        index ++;
                        groupA ++;
                    }
                    else
                    {
                        copy[index] = arr[groupB];
                        index ++;
                        groupB ++;
                    }
                }
                else
                {
                    if (copy[groupA] < copy[groupB])
                    {
                        arr[index] = copy[groupA];
                        index ++;
                        groupA ++;
                    }
                    else
                    {
                        arr[index] = copy[groupB];
                        index ++;
                        groupB ++;
                    }
                }
            }
            //当某一个分组没有元素以后，剩下的那个分组要是有元素，就依次把所有剩下的元素塞进去
            while (groupA < start + groupNum)
            {
                if (isArr == 1)
                {
                    copy[index] = arr[groupA];
                    index ++;
                    groupA ++;
                }
                else
                {
                    arr[index] = copy[groupA];
                    index ++;
                    groupA ++;
                }
            }
            while (groupB < start + 2 * groupNum && groupB < length)
            {
                if (isArr == 1)
                {
                    copy[index] = arr[groupB];
                    index ++;
                    groupB ++;
                }
                else
                {
                    arr[index] = copy[groupB];
                    index ++;
                    groupB ++;
                }
            }
            start += 2 * groupNum;
        }
        if (isArr == 1)
        {
            //由于有没有参与归并的分组，所以就把这些被暂时遗弃的分组再移到当前活动数组
            while (index < length)
            {
                copy[index] = arr[index];
                index ++;
            }
            isArr = 0;
        }
        else
        {
            while (index < length)
            {
                arr[index] = copy[index];
                index ++;
            }
            isArr = 1;
        }
        groupNum *= 2;
        groupCount = (int)ceil(length / groupNum);
    }
    //如果排完序，这个活跃数组不恰好是arr，那么就是讲copy数组的值一个个的赋过去
    if (isArr == 0)
    {
        for (i = 0; i < length; i++)
        {
            arr[i] = copy[i];
        }
    }
    //回收备用数组copy，以免造成内存浪费
    free(copy);
    //获取排完序当前时间
    gettimeofday(&time2, NULL);
    //返回时间差
    return time2.tv_sec - time1.tv_sec;
}
void printArr(int* arr, int length)
{
    for (int i = 0; i < length; i++)
    {
        printf("%d \t", arr[i]);
    }
    printf("\n");
}
int main(int argc, char** argv)
{
    srand(time(NULL));
    int* arr = (int*)malloc(sizeof(int) * 50000);
    for (int i = 0; i < 50000; i++)
    {
        arr[i] = rand();
    }
    printf("Select sort use time: %ld \n", selectSort(arr, 50000));
    for (int i = 0; i < 50000; i++) {
        arr[i] = rand();
    }
    printf("Insert sort use time: %ld \n", insertSort(arr, 50000));
    for (int i = 0; i < 50000; i++) {
        arr[i] = rand();
    }
    printf("Binary insert sort use time: %ld \n", binaryInsertSort(arr, 50000));
    for (int i = 0; i < 50000; i++) {
        arr[i] = rand();
    }
    printf("Shell sort use time: %ld \n", shellSort(arr, 50000));
    for (int i = 0; i < 50000; i++) {
        arr[i] = rand();
    }
    printf("Quick sort use time: %ld \n", quickSort(arr, 50000));
    for (int i = 0; i < 50000; i++) {
        arr[i] = rand();
    }
    printf("Bubble sort use time: %ld \n", bubbleSort(arr, 50000));
    for (int i = 0; i < 50000; i++) {
        arr[i] = rand();
    }
    printf("Heap sort use time: %ld \n", heapSort(arr, 50000));
    for (int i = 0; i < 50000; i++) {
        arr[i] = rand();
    }
    printf("Merger sort use time: %ld \n", mergerSort(arr, 50000));
    free(arr);
    return 0;
}