内部排序代码

编写程序实现下述五种算法，并用以下无序序列加以验证：

49，38，65，97，76，13，27，49

1．简单插入排序

2．冒泡排序

3．快速排序

4．归并排序

5．堆排序

 

//www.shuax.com
// 2009.12.01
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
        int *r;
        int length;
}
SqList;
 
void InitialList(SqList &L)
{
        //初始化顺序表L
        L.r = (int *)malloc(10 * sizeof(int));
        L.length = 1;
        L.r[L.length++] = 49;
        L.r[L.length++] = 38;
        L.r[L.length++] = 65;
        L.r[L.length++] = 97;
        L.r[L.length++] = 76;
        L.r[L.length++] = 13;
        L.r[L.length++] = 27;
        L.r[L.length++] = 49;
}
 
void PrintList(SqList L)
{
        //打印顺序表
        int i;
        for (i = 1;i < L.length;i++)
                printf("%d ", L.r[i]);
}
void InsertSort(SqList &L)
{
        //直接插入排序
        int i, j;
        for (i = 2; i <= L.length; ++i)
        {
                if (L.r[i] < L.r[i - 1])
                {
                        L.r[0] = L.r[i];                 // 复制为哨兵
                        for (j = i - 1; L.r[0] < L.r[j]; --j)
                                L.r[j + 1] = L.r[j];             // 记录后移
                        L.r[j + 1] = L.r[0];               // 插入到正确位置
                }
        }
}
void BubbleSort(SqList &L)
{
        //冒泡排序
        int i, j;
        int temp;
        for (i = 1;i < L.length - 1;i++)
        {
                for (j = i + 1;j < L.length;j++)
                {
                        if (L.r[i] > L.r[j])
                        {
                                temp = L.r[i];
                                L.r[i] = L.r[j];
                                L.r[j] = temp;
                        }
                }
        }
}
 
int Partition(SqList &L, int low, int high)
{
        int pivotkey;
        L.r[0] = L.r[low];
        pivotkey = L.r[low];
        while (low < high)
        {
                while (low < high && L.r[high] >= pivotkey) --high;
                L.r[low] = L.r[high];
                while (low < high && L.r[low] <= pivotkey) ++low;
                L.r[high] = L.r[low];
        }
        L.r[low] = L.r[0];
        return low;
}
void QSort(SqList &L, int low, int high)
{
        //快速排序
        int pivotloc;
        if (low < high)
        {
                pivotloc = Partition(L, low, high);
                QSort(L, low, pivotloc - 1);
                QSort(L, pivotloc + 1, high);
        }
}
 
void Merge (int SR[], int TR[], int i, int m, int n)
{
        int j, k;
        for (j = m + 1, k = i; i <= m && j <= n; ++k)
        {
                if (SR[i] < SR[j]) TR[k] = SR[i++];
                else TR[k] = SR[j++];
        }
        if (i <= m)
                while (k <= n && i <= m) TR[k++] = SR[i++];
        if (j <= n)
                while (k <= n && j <= n) TR[k++] = SR[j++];
}
void MSort(int SR[], int TR1[], int s, int t)
{
        //归并排序
        int m;
        int TR2[20];
        if (s == t) TR1[t] = SR[s];
        else
        {
                m = (s + t) / 2;
                MSort(SR, TR2, s, m);
                MSort(SR, TR2, m + 1, t);
                Merge(TR2, TR1, s, m, t);
        }
}
void HeapAdjust(SqList &H, int s, int m)
{
        int rc;
        rc = H.r[s];
        for (j = 2 * s; j <= m; j *= 2)
        {
                if (j < m && H.r[j] < H.r[j + 1]) ++j;
                if (rc >= H.r[j]) break;
                H.r[s] = H.r[j];
                s = j;
        }
        H.r[s] = rc;
}
void HeapSort(SqList &H)
{
        //堆排序
        int i;
        int temp;
        for (i = H.length / 2; i > 0; --i)
                HeapAdjust ( H, i, H.length );
        for (i = H.length; i > 1; --i)
        {
                temp = H.r[i];
                H.r[i] = H.r[1];
                H.r[1] = temp;
                HeapAdjust(H, 1, i - 1);
        }
}
int main()
{
        SqList L;
        printf("各种排序算法\n");
        //
        printf("\n%-20s", "直接插入排序：");
        InitialList(L);
        InsertSort(L);
        PrintList(L);
        //
        printf("\n%-20s", "冒泡排序：");
        InitialList(L);
        BubbleSort(L);
        PrintList(L);
        //
        printf("\n%-20s", "快速排序：");
        InitialList(L);
        QSort(L, 1, L.length);
        PrintList(L);
        //
        printf("\n%-20s", "归并排序：");
        InitialList(L);
        MSort(L.r, L.r, 1, L.length);
        PrintList(L);
        //
        printf("\n%-20s", "堆排序：");
        InitialList(L);
        HeapSort(L);
        PrintList(L);
 
        getchar();
        return 0;
}