排序算法--C语言版

冒泡排序、插入排序、希尔排序、选择排序、快速排序、堆排序

代码如下：

#include <stdio.h>

#define N  4
#define M  8

#define swap(a, b)  int tmp = a;     \
                        a   = b;           \
                        b   = tmp

void PrintArr(int *arr, int len);

//冒泡排序
void BubblingSort(int *arr, int len)
{
    //总共比较n-1趟
    for (int i = 1; i < len; i++)
    {
        for (int j = 1; j < len; j++)
        {
            if (arr[j] < arr[j-1])
            {
                swap(arr[j], arr[j-1]);
            }
        }
    }
    PrintArr(arr, len);
}

//选择排序
void SelectSort(int *arr, int len)
{
    //比较n-1趟
    for (int i = 0; i < len - 1; i++)
    {
        int nMinIdx = i;
        for (int j = i + 1; j < len; j++)
        {
            if (arr[j] < arr[nMinIdx]) 
            {
                nMinIdx = j;
            }
        }
        
        swap(arr[i], arr[nMinIdx]);
    }

    PrintArr(arr, len);
}

//插入排序
void InsertSort(int *arr, int len)
{
    for (int i = 1; i < len; i++)
    {
        int nKey = arr[i];
        int idx = i;
        for (int j = i; j > 0; j--)
        {
            //无序表第一个和有序表最后一个比较，插入到合适位置
            if (nKey < arr[j-1])
            {
                arr[j] = arr[j-1];
                idx = j - 1;
            }
            else break;
        }
        arr[idx] = nKey;
    }

    PrintArr(arr, len);
}

//希尔排序
void ShellSort(int *arr, int len)
{
    for (int gap = len / 2; gap > 0; gap /= 2)
    {
        for (int i = gap; i < len; i++)
        {
            for (int j = i; j >= gap; j -= gap)
            {
                if (arr[j] < arr[j - gap])
                {
                    swap(arr[j], arr[j - gap]);
                }
                else break;
            }
        }
    }

    PrintArr(arr, len);
}

//快速排序
void QuitSort(int *arr, int left, int right)
{
    if (left < right)
    {
        int nTmp = arr[left];
        int i = left, j = right;
        while (i < j)
        {
            while (i < j && arr[j] >= nTmp)  j--;
            while (i < j && arr[i] <= nTmp)  i++;
            if (i < j)
            {
                swap(arr[i], arr[j]);
            }
        }
        //把基准数和中间数作交换
        arr[left] = arr[i];
        arr[i] = nTmp;
        QuitSort(arr, left, i - 1);
        QuitSort(arr, j + 1, right);
    }

}

//堆排序
void Heapify(int *arr, int i, int nLastIdx)
{
    //记录最大值下标
    int nMaxIdx = i;
    if (i * 2 + 1 <= nLastIdx && arr[i * 2 + 1] > arr[nMaxIdx])
    {
        //左孩子
        nMaxIdx = i * 2 + 1;
    }
    if (i * 2 + 2 <= nLastIdx && arr[i * 2 + 2] > arr[nMaxIdx])
    {
        //右孩子
        nMaxIdx = i * 2 + 2;
    }
    //若有交换则继续对化被交换的那个子节点
    if (nMaxIdx != i)
    {
        swap(arr[i], arr[nMaxIdx]);
        Heapify(arr, nMaxIdx, nLastIdx);
    }
}
void HeapSort(int *arr, int len)
{
    //建堆，从最后一个非叶子节点开始，到最后到根节点下标0
    for (int i = len / 2 - 1; i >= 0; i--)
    {
        Heapify(arr, i, len - 1);
    }
    //从堆中取最大值，最后根节点不需要操作
    for (int i = len - 1; i > 0; i--)
    {
        swap(arr[i], arr[0]);
        Heapify(arr, 0, i - 1);
    }

    PrintArr(arr, len);
}


void PrintArr(int *arr, int len)
{
    for (int i = 0; i < len; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}


int main(void)
{
    //N组测试数据，每组M个元素
    int arr[N][M] = {
        {4,5,10,6,8,4,12,21},
        {14,20,5,76,32,20,7,14},
        {-3,-46,-29,0,102,32,-56,34},
        {-23123,-6781,-123322,-7876,-6781,3123,4223,-31243}
    };

    for (int i = 0; i < N; i++)
    {
        // BubblingSort(*(arr + i), M);
        // SelectSort(*(arr + i), M);
        // InsertSort(*(arr + i), M);
        // ShellSort(*(arr + i), M);
        // {
        //     QuitSort(*(arr + i), 0, M - 1);
        //     PrintArr(*(arr + i), M);
        // }
        HeapSort(*(arr + i), M);
    }

    return 0;
}