《數據結構》之內部排序算法比較

前言

各種內部排序算法的時間複雜度分析結果只給出了算法執行時間的階，或大概執行時間。試通過隨機的數據比較各算法的關鍵字比較次數和關鍵字移動次數，以取得直觀感受。
基本要求：
（1） 從以下常用的內部排序算法至少選取5種進行比較：直接插入排序；折半折入排序；希爾排序；起泡排序；快速排序；簡單選擇排序；堆排序；歸併排序。
（2） 待排序表的表長爲20000；其中的數據要用僞隨機數產生程序產生；至少要用5組不同的輸入數據作比較；比較的指標爲有關鍵字參加的比較次數和關鍵字移動次數（關鍵字交換計爲3次移動）。

直接上代碼

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define MAX 20000
typedef struct SORTTYPE
{
    char name[30]; //排序名稱
    int num_compare;       //比較的次數
    int num_move;       //移動的次數
} ST;        //存儲分析效率的數據
int num_compare = 0, num_move = 0; //關鍵字比較和移動的次數
ST st[5];                 //五種算法的分析數據
//直接插入排序算法
void InsertSort(int a[], int n);
//折半插入排序法
void BinInsertSort(int a[], int n);
//希爾排序算法
void ShellSort(int a[], int n);
//冒泡排序算法
void BubbleSort(int a[], int n);
/*快速排序算法*/
int partition(int a[], int s, int t); //一趟劃分
//對a[s..t]的元素進行快速排序
void QuickSort(int a[], int s, int t);
//菜單
void menu();
//調用直接插入排序的實現函數，即菜單1
void op1(int a[]);
void op2(int a[]);
void op3(int a[]);
void op4(int a[]);
void op5(int a[]);
void op6(int a[]);
//打印數組數據
void printArray(int a[]);
//給數組生成隨機數
void GetaandArray(int a[]);
//五種常見的算法
///////////////////////////////////////////////
//直接插入排序算法
void InsertSort(int a[], int n)
{
    int i, j;
    int tmp;
    for (i = 1; i < n; i++) //for循環內一定比較了n-1次，if判斷語句
    {
        if (a[i] < a[i - 1]) //一旦出現了逆序的關鍵字，就進行插入
        {
            tmp = a[i];
            j = i - 1;
            num_compare++;
            do //往後移動一個位置，騰空間給tmp；
            {
                a[j + 1] = a[j];
                num_move++; //移動加一
                j--;
                num_compare++; //比較次數加一
            }
            while (j >= 0 && a[j] > tmp);

            a[j + 1] = tmp; //最後把tmp放在對應的位置
            num_move += 2;  //移動的temp
        }
    }
}
////////////////////////////////////////////////////
//折半插入排序法
//把無序區插入到有序區裏，由於前面的插入排序法實現了有序，所以直接在
//有序區利用折半查找來尋找的改進算法
void BinInsertSort(int a[], int n)
{
    int i, j, low, high, mid;
    int tmp;
    for (i = 1; i < n; i++) //已經比較了n-1次
    {
        if (a[i] < a[i - 1])
        {
            tmp = a[i];
            low = 0;
            high = i - 1;
            num_compare++;
            while (low <= high)
            {
                num_compare++; //while進入比較
                mid = (low + high) / 2;
                if (tmp < a[mid])
                    high = mid - 1;
                else
                    low = mid + 1;
            }
            for (j = i - 1; j >= high + 1; j--)
            {
                a[j + 1] = a[j];
                num_move++; //移動次數加一
            }
            a[high + 1] = tmp;
            num_move += 2; //tmp交換
        }
    }
}
///////////////////////////////////////////////////
//希爾排序算法
void ShellSort(int a[], int n)
{
    int i, j, d;
    int tmp;
    d = n / 2;

    while (d > 0)
    {
        for (i = d; i < n; i++)
        {
            tmp = a[i];
            j = i - d;

            while (j >= 0 && tmp < a[j])
            {
                num_compare++;
                num_move++;
                a[j + d] = a[j];
                j = j - d;
            }
            a[j + d] = tmp;
            num_move += 2; //tmp進行兩次操作
        }
        d = d / 2;
    }
}
///////////////////////////////////////////////////
//冒泡排序算法
void BubbleSort(int a[], int n)
{
    int i, j;
    int tmp;
    for (i = 0; i < n - 1; i++)
    {
        for (j = n - 1; j > i; j--)
            if (a[j] < a[j - 1])
            {
                num_compare++;
                num_move += 3;
                tmp = a[j - 1];
                a[j - 1] = a[j];
                a[j] = tmp;
            }
    }
}
/////////////////////////////////////////////////////////
/*快速排序算法*/
int partition(int a[], int s, int t) //一趟劃分
{
    int i = s, j = t;
    int tmp = a[i]; //以a[i]爲基準
    while (i < j)   //從兩端交替向中間掃描,直至i=j爲止
    {
        while (j > i && a[j] >= tmp)
        {
            j--;           //從右向左掃描,找一個小於tmp的a[j]
            num_compare++; //進行比較
        }
        a[i] = a[j]; //找到這樣的a[j],放入a[i]處
        num_move++;  //移動+1
        while (i < j && a[i] <= tmp)
        {
            i++;           //從左向右掃描,找一個大於tmp的a[i]
            num_compare++; //比較加一
        }
        a[j] = a[i]; //找到這樣的a[i],放入a[j]處
        num_move++;  //移動加一
    }
    a[i] = tmp;
    num_move += 2; //temp的交換
    return i;
}

void QuickSort(int a[], int s, int t)
//對a[s..t]的元素進行快速排序
{
    int i;
    if (s < t) //區間內至少存在兩個元素的情況
    {
        i = partition(a, s, t);
        QuickSort(a, s, i - 1); //對左區間遞歸排序
        QuickSort(a, i + 1, t); //對右區間遞歸排序
    }
}
/////////////////////////////////////////////////////

void menu()
{
    printf("***************************************************\n");
    printf("\t\t1.直接插入排序法\n");
    printf("\t\t2.折半插入排序法\n");
    printf("\t\t3.希爾排序法\n");
    printf("\t\t4.冒泡排序法\n");
    printf("\t\t5.快速排序法\n");
    printf("\t\t6.效率比較\n");
    printf("\t\t7.退出\n");
    printf("***************************************************\n");
    printf("請選擇操作：");
}
void printArray(int a[]) //打印數組數據
{
    int i;
    for (i = 0; i < MAX; i++)
        printf("%2d%c", a[i], (i+1)%40 ? ' ' : '\n');
    putchar(10);
}

//調用直接插入排序的實現函數，即菜單1
void op1(int a[])
{
    GetaandArray(a);
    printf("僞隨機數已經生成的20000個新的隨機數\n");
    //打印排序前的數組
    // printArray(a);
    InsertSort(a, MAX);
    // printf("\n利用直接插入排序後的數列如下：\n");
    //打印排序後的數組
    // printArray(a);
    printf("\n\n直接插入排序法：\n一共比較了%d次，移動了%d次\n", num_compare, num_move);
    st[0].num_compare = num_compare;
    st[0].num_move = num_move;
    strcpy(st[0].name, "直接插入排序");
}
void op2(int a[])
{
    GetaandArray(a);
    printf("已經生成20000個新的隨機數\n");
    //打印排序前的數組
    //  printArray(a);
    num_compare = 0;
    num_move = 0;
    BinInsertSort(a, MAX);
    //  printf("\n利用折半插入排序後的數列如下：\n");
    //打印排序後的數組
    // printArray(a);
    printf("\n\n折半插入排序：\n一共比較了%d次，移動了%d次\n", num_compare, num_move);
    st[1].num_compare = num_compare;
    st[1].num_move = num_move;
    strcpy(st[1].name, "折半插入排序");
}

void GetaandArray(int a[]) //爲數組獲得隨機數
{
    int i;
    for (i = 0; i < MAX; i++)
        a[i] = rand() % 100;
}
void op3(int a[])
{
    GetaandArray(a);
    printf("已經生成20000個新的隨機數\n");
    //打印排序前的數組
    //printArray(a);
    num_compare = 0;
    num_move = 0;
    ShellSort(a, MAX);
    //printf("\n利用希爾排序算法後的數列如下：\n");
    //打印排序後的數組
    //printArray(a);


    printf("\n\n希爾排序算法：\n一共比較了%d次，移動了%d次\n", num_compare, num_move);
    st[2].num_compare = num_compare;
    st[2].num_move = num_move;
    strcpy(st[2].name, "希爾排序算法");
}
void op4(int a[])
{
    GetaandArray(a);
    printf("已經生成20000個新的隨機數\n");

    //打印排序前的數組
    // printArray(a);

    num_compare = 0;
    num_move = 0;
    BubbleSort(a, MAX);

    //  printf("\n利用冒泡排序法後的數列如下：\n");
    //打印排序後的數組

    //  printArray(a);

    printf("\n\n冒泡排序算法：\n一共比較了%d次，移動了%d次\n", num_compare, num_move);
    st[3].num_compare = num_compare;
    st[3].num_move = num_move;
    strcpy(st[3].name, "冒泡排序算法");
}
void op5(int a[])
{
    GetaandArray(a);
    printf("已經生成20000個新的隨機數\n");

    //打印排序前的數組
    //printArray(a);
    num_compare = 0;
    num_move = 0;
    QuickSort(a, 0, MAX);
    //  printf("\n利用快速排序算法後的數列如下：\n");
    //打印排序後的數組
    // printArray(a);
    printf("\n\n快速排序算法：\n一共比較了%d次，移動了%d次\n", num_compare, num_move);
    st[4].num_compare = num_compare;
    st[4].num_move = num_move;
    strcpy(st[4].name, "快速排序算法");
}
void op6(int a[])
{
    int i;
    printf("各種排序算法的比較於移動次數的對比：\n\n");
    printf("   名稱          比較次數          移動次數\n");

    for (i = 0; i < 5; i++)
    {
        printf("%-18s%-18d %d\n", st[i].name, st[i].num_compare, st[i].num_move);
    }
}
int main()
{
    int a[MAX]; //列表數組
    int op;
    srand((unsigned)time(NULL)); //隨機種子
    do
    {
        system("cls");
        menu();
        scanf("%d", &op);
        switch (op)
        {
        case 1:
            op1(a);
            break;
        case 2:
            op2(a);
            break;
        case 3:
            op3(a);
            break;
        case 4:
            op4(a);
            break;
        case 5:
            op5(a);
            break;
        case 6:
            op6(a);
            break;
        default:
            break;
        }
        system("pause");

    }while(op!=7);
    return 0;
}

效果圖