排序总结

代码参考<<数据结构与算法分析-c语言描述>>

复杂度分析略。

1.插入排序

void insertionSort(ElementType A[], int N)
{
    int j;
    for (int i = 1; i < N; ++i)
    {
        int tem = A[i];
        for (j = i; j > 0 && tem < A[j - 1]; j--)
        {
            A[j] = A[j - 1];
        }
        A[j] = tem;
    }
}

2.堆排序

void percDown(ElementType A[], int i, int N)          //明确函数的作用
{                                                   //在有N个元素的堆中，调整第i个元素
    int child;
    int tem;
    for (tem = A[i]; 2 * i + 1 < N; i = child)      //终止条件左儿子不存在
    {
        child = 2 * i + 1;
        if (child + 1 < N && A[child + 1] > A[child])           //若右儿子存在，则选择左右儿子中较大的
        {
            child++;
        }
        if (A[child] > tem)                         //若儿子中有比A[i]大的元素，则将空穴下移
            A[i] = A[child];
        else
            break;
    }
    A[i] = tem;
}
void heapSort(ElementType A[], int N)
{
    for (int i = N / 2; i >= 0; --i)
    {
        percDown(A, i, N);              //建堆
    }

    for (int i = N - 1; i > 0; --i)
    {
        int tem;                     //将最大的元素放到最后,最后的元素放到首元素
        tem = A[0];
        A[0] = A[i];
        A[i] = tem;

        percDown(A, 0, i);                  //调整首元素的位置，以保持堆序性
    }
}

3.并合排序

void merge(ElementType A[], ElementType temArray[], int begin, int center, int end)       //并合左右部分
{
    int lpos = begin;
    int rpos = center + 1;
    int lEnd = center;
    int rEnd = end;
    int pos = begin;
    while (lpos <= lEnd && rpos <= rEnd)
    {
        if (A[lpos] < A[rpos])
            temArray[pos++] = A[lpos++];
        else
            temArray[pos++] = A[rpos++];
    }

    while (lpos <= lEnd)
        temArray[pos++] = A[lpos++];
    while (rpos <= rEnd)
        temArray[pos++] = A[rpos++];

    for (int i = begin; i <= end; i++)          //重新将排序后的元素拷贝到原数组中
        A[i] = temArray[i];
}
void MSort(ElementType A[], ElementType temArray[], int begin, int end)         //递归地将由begin,end指示首位的数组排序后，放入temArray中
{
    int center = (begin + end) / 2;
    if (begin < end)
    {
        MSort(A, temArray, begin, center);                              //排序左半部分
        MSort(A, temArray, center + 1, end);                            //排序右半部分
        merge(A, temArray, begin, center, end);                                                         //并合
    }
}
void mergeSort(ElementType A[], int N)              //归并排序,递归分治
{
    ElementType *temArray = (ElementType*)malloc(sizeof(ElementType) * N);
    if (temArray != NULL)
    {
        MSort(A, temArray, 0, N - 1);
        free(temArray);
    }
    else
    {
        cout << "out of space!";
        exit(1);
    }
}

4.快速排序

void swap(int *a, int *b)
{
    int tem;
    tem = *a;
    *a = *b;
    *b = tem;
}

void Qsort(int A[], int Left, int Right)
{
    if (Left < Right)
    {
        int i;
        int j;
        int center = (Left + Right) / 2;            //选取枢纽元
        int pivot = A[center];
        swap(A[center], A[Right]);                  //将枢纽元置后
        i = Left;
        j = Right - 1;
        while (1)                                   //以枢纽元为标准分割左右区块
        {
            while (A[i] < pivot && i < Right)           //****遇到与枢纽元相同的元素停止*****
                i++;
            while (A[j] > pivot && j > 0)
                j--;
            if (i <= j)
                swap(A[i++], A[j--]);               //***交换后记得更新i,j的值***
            else
                break;
        }//end while
        swap(A[i], A[Right]);                   //将枢纽元置位，完成分割
        Qsort(A, Left, i - 1);                    //递归排序左半部分
        Qsort(A, i + 1, Right);                     //递归排序有半部分

    }//end if
}

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