排序

① 生成100个在[200, 1000]之间的整数保存数组A中，以此数组元素作为关键字，采用希尔排序算法按非递减方式进行排序，给出操作的结果及相应的操作次数；

③ 生成200个在[200, 10000]之间的整数保存数组A中，以此数组元素作为关键字，采用快速排序算法按非递减方式进行排序，给出操作的结果及相应的操作次数；

④ 生成500个在[200, 10000]之间的整数保存数组A中，以此数组元素作为关键字，采用堆排序算法按非递减方式进行排序，给出操作的结果及相应的操作次数；

⑤ 主函数通过调用函数实现以上操作。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef int KeyType;
typedef struct
{
    KeyType key;
}DataType;
/*            随机数生成                */ 
void CreateNum_A(DataType *num, int n)
{
    int i = 0, j, x, flag = 0;
    int *a = (int *)malloc(sizeof(int) * n);
    DataType *array = (DataType *)malloc(sizeof(DataType) * n);
    srand((int) time(NULL));
    
    while(i < n)
    {
        x = rand() % 1000 + 1;
        for(j = 0; j < i; j++) if(x == a[j]) flag = 1;
        if(x >= 200 && flag != 1)     a[i++] = x;
        
        flag = 0;
    }
    for(i = 0; i < n; i++) num[i].key = a[i];
}
void CreateNum_B(DataType *num, int n)
{
    int i = 0, j, x, flag = 0;
    int *a = (int *)malloc(sizeof(int) * n);
    
    srand((int) time(NULL));
    
    while(i < n)
    {
        x = rand() % 10000 + 1;
        for(j = 0; j < i; j++) if(x == a[j]) flag = 1;
        if(x >= 200 && flag != 1)     a[i++] = x;
        
        flag = 0;
    }
    for(i = 0; i < n; i++) num[i].key = a[i];
}
/*              希尔排序            */
int ShellSort(DataType *a, int n, int *d, int numOfD)
{
    int i, j, k, m, span, num = 0;
    DataType temp;
    
    for(m = 0; m < numOfD; m++)
    {
        span = d[m];
        for(k = 0; k < span; k++)
        {
            for(i = k; i < n-span; i = i+span)
            {
                temp = a[i+span];
                j = i;
                while(j > -1 && temp.key < a[j].key)
                {
                    a[j+span] = a[j];
                    j = j-span;
                    num++;
                }
                a[j+span] = temp;
            }
        }
    }
    
    return num;
} 
/*           快速排序          */
void QuickSort(DataType *a, int low, int high, int *num)
{
    int i = low, j = high; 
    DataType temp = a[low];
    
    while(i < j)
    {
        while(i < j && temp.key <= a[j].key) j--;
        if(i < j)
        {
            a[i] = a[j];
            i++;
            (*num)++;
        }
        while(i < j && a[i].key < temp.key) i++;
        if(i < j)
        {
            a[j] = a[i];
            j--;
            (*num)++;
        }
    } 
    a[i] = temp;
    if(low < i) QuickSort(a, low, i-1, num);
    if(i < high) QuickSort(a, j+1, high, num);
    
} 
/*         堆排序          */
void CreatHeap(DataType *a, int n, int h, int *num)
{
    int i, j, flag;
    DataType temp;
    
    i = h;
    j = 2 * i + 1;
    temp = a[i];
    flag = 0;
    
    while(j < n - 1 && flag != 1) 
    {
        if(j < n - 1 && a[j].key < a[j + 1].key) j++;
        if(temp.key > a[j].key) flag = 1;
        else
        {
            a[i] = a[j];
            i = j;
            j = 2 * i + 1;
            (*num)++;
        }
    }    
    a[i] = temp;
} 
void InitCreatHeap(DataType *a, int n, int *num)
{
    int i;
    for(i = (n -2) / 2; i >= 0; i--) CreatHeap(a, n, i, num);
}
void HeapSort(DataType *a, int n, int *num)
{
    int i;
    DataType temp;
    
    InitCreatHeap(a, n, num);
    for(i = n - 1; i > 0; i--)
    {
        temp = a[0];
        a[0] = a[i];
        a[i] = temp;
        CreatHeap(a, i, 0, num);
    }
}
void main()
{
    
    int d[] = {50, 20, 10, 5, 1};
    int i, num;
    DataType a1[100], a2[200], a3[500];
    
    //希尔排序 
    printf("希尔排序前的随机数为：\n");
    CreateNum_A(a1, 100);
    for(i = 0; i < 100; i++) printf("%-5d", a1[i].key); 
    num = ShellSort(a1, 100, d, 5);
    printf("\n\n经过%d次的交换处理后，希尔排序后的结果为:\n", num);
    for(i = 0; i < 100; i++) printf("%-5d", a1[i].key); 
    
    //快速排序
    num = 0;
    printf("\n\n快速排序前的随机数为；\n");
    CreateNum_B(a2, 200);
    for(i = 0; i < 200; i++) printf("%6d", a2[i].key);
    QuickSort(a2, 0, 199, &num);
    printf("\n\n经过%d次的交换处理后，快速排序后的结果为:\n", num);
    for(i = 0; i < 200; i++) printf("%6d", a2[i].key);

    //堆排序
    num  = 0;
    printf("\n\n堆排序前的随机数为；\n");
    CreateNum_B(a3, 500);
    for(i = 0; i < 500; i++) printf("%6d", a3[i].key);
    HeapSort(a3, 500, &num);
    printf("\n\n经过%d次的交换处理后，堆排序后的结果为:\n", num);
    for(i = 0; i < 500; i++) printf("%6d", a3[i].key);
    
}