常见排序代码实现

插入排序

#include <stdio.h>
typedef int ElementType;

void InsertionSort(ElementType A[], int N);

void InsertionSort(ElementType A[], int N)
{
    int i, P;
    ElementType tmp;

    for (P = 1; P < N; P++)
    {
        tmp = A[P];
        for (i = P; i > 0 && A[i - 1] > tmp; i--)
                A[i] = A[i - 1];
        A[i] = tmp;
    }
}

冒泡排序

#include <stdio.h>
typedef int ElementType;

void BubbleSort(ElementType A[], int N);


void BubbleSort(ElementType A[], int N)
{
    int i, j;
    ElementType tmp;

    for (i = 0; i < N; i++)
        for (j = 0; j < N; j++)
        {
            if (A[j] > A[j + 1])
            {
                tmp = A[j];
                A[j] = A[j + 1];
                A[j + 1] = tmp;
            }
        }
}

选择排序

#include <stdio.h>
typedef int ElementType;

void  SelectionSort (ElementType A[], int N);

void SelectionSort(ElementType A[], int N)
{
    int i, j, tmpIndx; //tmp存储每一次变量最小值的索引
    ElementType tmp;

    for(i = 0; i < N; i++)
    {
        tmpIndx = i;
        for(j = i + 1; j < N; j++)
        {
            if(A[j] < A[j - 1])
                tmpIndx = j;
        }
        tmp = A[i];
        A[i] = A[tmpIndx];
        A[tmpIndx] = tmp;
    }
}

希尔排序

#include <stdio.h>
typedef int ElementType;

void ShellSort(ElementType A[], int N);

int main()
{
    int A[10] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
    ShellSort(A, 10);
    for(int i = 0; i < 10; i++)
        printf("%d ", A[i]);
}
void ShellSort(ElementType A[], int N)
{
    int i, j, increment;
    ElementType tmp;

    for (increment = N / 2; increment > 0; increment /= 2)
    {   //logN
        for (i = increment; i < N; i++)
        {//N
            tmp = A[i];
            for(j = i; j >= increment; j -= increment)
                if(tmp < A[j - increment])
                    A[j] = A[j - increment];
                else
                    break;
            A[j] = tmp;
        }
    }
}

堆排序

/*1.把无序数组构建成二叉堆*/
/*2.循环删除堆顶元素，移到集合尾部，调节堆产生新的堆顶*/
#include <stdio.h>
typedef int ElementType;
#define LeftChild(i) (2 * (i) + 1)

void PercDown(ElementType A[], int i, int N);
void HeapSort(ElementType A[], int N);
void Swap(ElementType *a, ElementType *b);

void PercDown(ElementType A[], int i, int N)
{
    int Child;
    ElementType tmp;

    
    for (tmp = A[i]; LeftChild(i) < N; i = Child)
    {
        Child = LeftChild(i);
        if (Child != N - 1 && A[Child + 1] > A[Child])
            Child++;
        if (A[Child] > tmp)
            A[i] = A[Child];
        else
            break;
    }
    A[i] = tmp;
}

void HeapSort(ElementType A[], int N)
{
    int i;
    ElementType tmp;

    for (i = N / 2; i >= 0; i--)
        PercDown(A, i, N); /*建堆*/
    
    while (N != 0)
    {
        tmp = A[0];
        A[0] = A[N - 1];
        A[N - 1] = tmp;
        PercDown(A, 0, N - 1);
        N = N - 1;
    }

    // for(i = N - 1; i > 0; i--)
    // {
    //     Swap(&A[0], &A[i]);
    //     PercDown(A, 0, i);
    // }
}/8

void Swap(ElementType *a, ElementType *b)
{
    ElementType tmp;

    tmp = *a;
    *a = *b;
    *b = tmp;
}

归并排序

#include <stdio.h>
#include <stdlib.h>
typedef int ElementType;

void MSort(ElementType A[], ElementType TmpArray[],
           int Left, int Right);
void MergeSort(ElementType A[], int N);
void Merge(ElementType A[], ElementType TmpArray[],
           int Lpos, int Rpos, int RightEnd);

void MSort(ElementType A[], ElementType TmpArray[],
           int Left, int Right)
{
    int Center;

    if (Left < Right)
    {
        Center = (Left + Right) / 2;
        MSort(A, TmpArray, Left, Center);
        MSort(A, TmpArray, Center + 1, Right);
        Merge(A, TmpArray, Left, Center + 1, Right);
    }
}

void MergeSort(ElementType A[], int N)
{
    ElementType *TmpArray;

    TmpArray = malloc(N * sizeof(ElementType));
    if (TmpArray != NULL)
    {
        MSort(A, TmpArray, 0, N - 1);
        free(TmpArray);
    }
    else
    {
        printf("No space for tmp array!!!\n");
        exit(0);
    }
}

void Merge(ElementType A[], ElementType TmpArray[],
           int Lpos, int Rpos, int RightEnd)
{
    int i, LeftEnd, NumElements, TmpPos;

    LeftEnd = Rpos - 1;
    TmpPos = Lpos;
    NumElements = RightEnd - Lpos + 1;

    /*main loop*/
    while(Lpos <= LeftEnd && Rpos <= RightEnd)
        if(A[Lpos] <= A[Rpos])
            TmpArray[TmpPos++] = A[Lpos++];
        else
            TmpArray[TmpPos++] = A[Rpos++];

    while(Lpos <= LeftEnd) /*Copy rest of first half*/
        TmpArray[TmpPos++] = A[Lpos++];
    while(Rpos <= RightEnd) /*Copy rest of second half*/
        TmpArray[TmpPos++] = A[Rpos++];

    /*Copy TmpArray back*/
    for(i = 0; i < NumElements; i++, RightEnd--)
        A[RightEnd] = TmpArray[RightEnd];
}

归并排序非递归实现

#include <stdio.h>
#include <stdlib.h>
typedef int ElementType;

void Merge(ElementType A[], ElementType TmpArray[],
           int Lpos, int Rpos, int RightEnd);
void MergeSort(ElementType A[], int N);
int min(int a, int b);

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

int min(int a, int b)
{
    return a < b ? a : b;
}

void MergeSort(ElementType A[], int N)
{
    ElementType *TmpArray;
    int SubListSize, Part1Start, Part2Start, Part2End;

    TmpArray = malloc(sizeof(ElementType) * N);
    if (TmpArray == NULL)
    {
        printf("Out of space!!!\n");
        exit(0);
    }
    else
    {
        for (SubListSize = 1; SubListSize < N; SubListSize *= 2)
        {
            Part1Start = 0;
            while (Part1Start + SubListSize < N)
            {
                Part2Start = Part1Start + SubListSize;
                Part2End = min(N, Part2Start + SubListSize - 1);
                Merge(A, TmpArray, Part1Start, Part2Start, Part2End);
                Part1Start = Part2End + 1;
            }
        }
    }
}

void Merge(ElementType A[], ElementType TmpArray[],
           int Lpos, int Rpos, int RightEnd)
{
    int i, LeftEnd, NumElements, TmpPos;

    LeftEnd = Rpos - 1;
    TmpPos = Lpos;
    NumElements = RightEnd - Lpos + 1;

    /*main loop*/
    while (Lpos <= LeftEnd && Rpos <= RightEnd)
        if (A[Lpos] <= A[Rpos])
            TmpArray[TmpPos++] = A[Lpos++];
        else
            TmpArray[TmpPos++] = A[Rpos++];

    while (Lpos <= LeftEnd) /*Copy rest of first half*/
        TmpArray[TmpPos++] = A[Lpos++];
    while (Rpos <= RightEnd) /*Copy rest of second half*/
        TmpArray[TmpPos++] = A[Rpos++];

    /*Copy TmpArray back*/
    for (i = 0; i < NumElements; i++, RightEnd--)
        A[RightEnd] = TmpArray[RightEnd];
}

快速排序

#include <stdio.h>
#include <stdlib.h>
#define Cutoff (3)
typedef int ElementType;


void Swap(ElementType *a, ElementType *b);
void InsertionSort(ElementType A[], int N);
void QuickSort(ElementType A[], int N);
ElementType Median3(ElementType A[], int Left, int Right);
void Qsort(ElementType A[], int Left, int Right);

void Swap(ElementType *a, ElementType *b)
{
    ElementType tmp;

    tmp = *a;
    *a = *b;
    *b = tmp;
}

void QuickSort(ElementType A[], int N)
{
    Qsort(A, 0, N - 1);
}

ElementType Median3(ElementType A[], int Left, int Right)
{
    int Center = (Left + Right) / 2;

    if (A[Left] > A[Center])
        Swap(&A[Left], &A[Center]);
    if (A[Left] > A[Right])
        Swap(&A[Left], &A[Right]);
    if (A[Center] > A[Right])
        Swap(&A[Center], &A[Right]);

    /*Invariant: A[Left] <= A[Center] <= A[Right]*/

    Swap(&A[Center], &A[Right - 1]);
    return A[Right - 1];
}

void Qsort(ElementType A[], int Left, int Right)
{
    int i, j;
    ElementType Pivot;

    if (Left + Cutoff <= Right)
    {
        Pivot = Median3(A, Left, Right);
        i = Left;
        j = Right - 1;
        for(;;)
        {
            while(A[++i] < Pivot){}
            while(A[--j] > Pivot){}
            if(i < j)
                Swap(&A[i], &A[j]);
            else
                break;
        }
        Swap(&A[i], &A[Right - 1]); /*Restore pivot*/

        Qsort(A, Left, i - 1);
        Qsort(A, i + 1, Right);
    }
    else /*Do an insertion sort on the subrray*/
        InsertionSort(A + Left, Right - Left + 1);
}

void InsertionSort(ElementType A[], int N)
{
    int i, P;
    ElementType tmp;

    for (P = 1; P < N; P++)
    {
        tmp = A[P];
        for (i = P; i > 0 && A[i - 1] > tmp; i--)
            A[i] = A[i - 1];
        A[i] = tmp;
    }
}