排序算法的实现

设一组数据，分别用直接插入排序法、

 

冒泡排序法、快速排序法、简单选择排序法、堆排序法、归并排序法进行排序。

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <io.h>
#include <math.h>
#include <time.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAX_LENGTH_INSERT_SORT 7 /* 用于快速排序时判断是否选用插入排序阙值 */

typedef int Status;


#define MAXSIZE 10000  /* 用于要排序数组个数最大值，可根据需要修改 */
typedef struct
{
    int r[MAXSIZE+1];	/* 用于存储要排序数组，r[0]用作哨兵或临时变量 */
    int length;			/* 用于记录顺序表的长度 */
} SqList;

/* 交换L中数组r的下标为i和j的值 */
void swap(SqList *L,int i,int j)
{
    int temp=L->r[i];
    L->r[i]=L->r[j];
    L->r[j]=temp;
}

void print(SqList L)
{
    int i;
    for(i=1; i<L.length; i++)
        printf("%d,",L.r[i]);
    printf("%d",L.r[i]);
    printf("\n");
}

/* 对顺序表L作直接插入排序 */
void InsertSort(SqList *L)
{
    int i,j;
    for(i=2; i<=L->length; i++)
    {
        if (L->r[i]<L->r[i-1]) /* 需将L->r[i]插入有序子表 */
        {
            L->r[0]=L->r[i]; /* 设置哨兵 */
            for(j=i-1; L->r[j]>L->r[0]; j--)
                L->r[j+1]=L->r[j]; /* 记录后移 */
            L->r[j+1]=L->r[0]; /* 插入到正确位置 */
        }
    }
}



/* 对顺序表L作冒泡排序 */
void BubbleSort(SqList *L)
{
    int i,j;
    for(i=1; i<L->length; i++)
    {
        for(j=L->length-1; j>=i; j--) /* 注意j是从后往前循环 */
        {
            if(L->r[j]>L->r[j+1]) /* 若前者大于后者（注意这里与上一算法的差异）*/
            {
                swap(L,j,j+1);/* 交换L->r[j]与L->r[j+1]的值 */
            }
        }
    }
}



/* 快速排序******************************** */

/* 交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在位置 */
/* 此时在它之前(后)的记录均不大(小)于它。 */
int Partition(SqList *L,int low,int high)
{
    int pivotkey;

    pivotkey=L->r[low]; /* 用子表的第一个记录作枢轴记录 */
    while(low<high) /*  从表的两端交替地向中间扫描 */
    {
        while(low<high&&L->r[high]>=pivotkey)
            high--;
        swap(L,low,high);/* 将比枢轴记录小的记录交换到低端 */
        while(low<high&&L->r[low]<=pivotkey)
            low++;
        swap(L,low,high);/* 将比枢轴记录大的记录交换到高端 */
    }
    return low; /* 返回枢轴所在位置 */
}

/* 对顺序表L中的子序列L->r[low..high]作快速排序 */
void QSort(SqList *L,int low,int high)
{
    int pivot;
    if(low<high)
    {
        pivot=Partition(L,low,high); /*  将L->r[low..high]一分为二，算出枢轴值pivot */
        QSort(L,low,pivot-1);		/*  对低子表递归排序 */
        QSort(L,pivot+1,high);		/*  对高子表递归排序 */
    }
}

/* 对顺序表L作快速排序 */
void QuickSort(SqList *L)
{
    QSort(L,1,L->length);
}

/* 对顺序表L作简单选择排序 */
void SelectSort(SqList *L)
{
    int i,j,min;
    for(i=1; i<L->length; i++)
    {
        min = i;						/* 将当前下标定义为最小值下标 */
        for (j = i+1; j<=L->length; j++) /* 循环之后的数据 */
        {
            if (L->r[min]>L->r[j])	/* 如果有小于当前最小值的关键字 */
                min = j;				/* 将此关键字的下标赋值给min */
        }
        if(i!=min)						/* 若min不等于i，说明找到最小值，交换 */
            swap(L,i,min);				/* 交换L->r[i]与L->r[min]的值 */
    }
}


#define N 9
int main()
{
    int i;

    int d[N]= {50,10,90,30,70,40,80,60,20};

    SqList l0,l1,l2,l3,l4,l5,l6,l7,l8,l9,l10,l11;

    for(i=0; i<N; i++)
        l0.r[i+1]=d[i];
    l0.length=N;
    l1=l2=l3=l4=l5=l6=l7=l8=l9=l10=l11=l0;
    printf("排序前:\n");
    print(l0);
    printf("直接插入排序:\n");
    InsertSort(&l4);
    print(l4);

    printf("冒泡排序:\n");
    BubbleSort(&l1);
    print(l1);

    printf("快速排序:\n");
    QuickSort(&l9);
    print(l9);

    printf("选择排序:\n");
    SelectSort(&l3);
    print(l3);

    return 0;


    printf("直接插入排序:\n");
    InsertSort(&l1);
    print(l1);

    printf("冒泡排序:\n");
    BubbleSort(&l2);
    print(l2);

    printf("快速排序:\n");
    QuickSort(&l3);
    print(l3);

    printf("选择排序:\n");
    SelectSort(&l4);
    print(l4);

    return 0;
}

结果截图：