排序算法的C语言实现(上 比较类排序：插入排序、快速排序与归并排序)

/*issort.c*/
#include <stdlib.h>
#include <string.h>

#include "sort.h"

/*issort 插入排序*/
int issort(void *data, int size, int esize, int (*compare)(const void *key1, const void *key2))
{
    char *a = data;
    void *key;
    int   i,j;

    /*为key元素分配一块空间*/
    if((key =(char *)malloc(esize)) == NULL)
        return -1;

    /*将元素循环插入到已排序的数据集中*/
    for(j=1; j < size; j++)
    {
        /*取无序数据集中的第j个元素，复制到key中*/
        memcpy(key, &a[j*esize], esize);
        /*设i为j紧邻的前一个元素*/
        i = j - 1;

        /*从i开始循环查找可以插入key的正确位置*/
        /*key和第i个元素对比，如果小于第i个元素就复制i元素到i+1的位置;i递减循环对比*/
        while(i >= 0 && compare(&a[i*esize],key)>0)
        {
            memcpy(&a[(i+1)*esize],&a[i*esize],esize);
            i--;
        }
        /*将key元素的值（也就是要插入的值）复制到while循环后i+1的位置，也就是要插入的位置*/
        memcpy(&a[(i+1)*esize],key,esize);
    }
    /*释放key的空间*/
    free(key);

    return 0;
}

/*qksort.c*/
#include <stdlib.h>
#include <string.h>

#include "sort.h"

/*compare_int  比较函数*/
static int compare_int(const void *int1, const void *int2)
{
    /*对比两个整数的大小（用于中位数分区）*/
    if(*(const int *)int1 > *(const int *)int2)
        return 1;
    else if(*(const int *)int1 < *(const int *)int2)
        return -1;
    else 
        return 0;
}

/*partition 分割函数*/
static int partition(void *data, int esize, int i, int k, int (*compare)(const void *key1, const void *key2))
{
    char *a=data;
    void *pval,
         *temp;
    int  r[3];
    
    /*为分割值和交换值变量分配空间*/
    if((pval = malloc(esize)) == NULL)
        return -1;
    
    if((temp = malloc(esize)) == NULL)
    {
        /*如果为交换变量分配空间失败，则将分割变量的空间一起释放掉*/
        free(pval);
        return -1;
    }
    
    /*用中位数法找到分割值*/
    r[0] = (rand()%(k-i+1))+i;
    r[1] = (rand()%(k-i+1))+i;
    r[2] = (rand()%(k-i+1))+i;
    /*调用插入排序函数对三个随机数排序*/
    issort(r,3,sizeof(int),compare_int);
    /*把排好序的三个数的中间值复制给分割值*/
    memcpy(pval,&a[r[1]*esize,esize);
    
    /*围绕分割值把数据分割成两个分区*/
    /*准备变量范围，使i和k分割超出数组边界*/
    i--;
    k++;
    
    while(1)
    {
        /*k向左移动，直到找到一个小于或等于分割值的元素，这个元素处于错误的位置*/
        do
        {
            k--;
        }
        while(compare(&a[k*esize],pval)>0);
        
        /*i向右移动，直到找到一个大于或等于分割值的元素，这个元素处于错误的位置*/
        do
        {
            i++;
        }
        while(compare(&a[i*esize],pval)<0);
        
        /*直到i和k重合,跳出分区，否则交换处于错误位置的元素*/
        if(i >= k)
        {
            break;
        }
        else
        {
            memcpy(temp, &a[i*esize], esize);
            memcpy(&a[i*esize], &a[k*esize], esize);
            memcpy(&a[k*esize], temp, esize);
        }
    }
    
    /*释放动态分配的空间*/
    free(pval);
    free(temp);
    
    /*返回两个分区中间的分割值*/
    return k;
}

/*qksort  快速排序函数*/
int qksort(void *data, int size, int esize, int i, int k, int(*compare)(const void *key1, const void *key2))
{
    int j;
    
    /*递归地继续分区，直到不能进一步分区*/
    while(i < k)
    {
        /*决定从何处开始分区*/
        if((j = partition(data,esize,i,k,compare))<0)
            return -1;
        
        /*递归排序左半部分*/
        if(qksort(data,size,esize,i,j,compare) < 0)
            return -1;
        
        /*递归排序右半部分*/
        i=j+1;
    }
    return 0;
}

/*directls.h*/
#ifndef DIRECTLS_H
#define DIRECTLS_H

#include <dirent.h>

/*为目录列表创建一个数据结构*/
typedef struct Directory_
{
    char name[MAXNAMLEN+1];
}Directory;

/*函数接口定义*/
int directls(const char *path,Directory **dir);

#endif // DIRECTLS_H

/*directls.c*/
#include <dirent.h> /*是POSIX.1标准定义的unix类目录操作的头文件，包含了许多UNIX系统服务的函数原型，例如opendir函数、readdir函数. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "directls.h"
#include "sort.h"

/*compare_dir 目录比较*/
static int compare_dir(const void *key1,const void key2)
{
    int retval;
    if((retval = strcmp(((const Directort *)key1)->name,((const Directory *)key2)->name))>0)
        return 1;
    else if (retval < 0)
        return -1;
    else 
        return 0;
}

/*directls*/
int directls(const char *path,Directory **dir)
{
    DIR           *dirptr;
    Directory     *temp;
    struct dirent *curdir;
    int           count,i;
    
    /*打开目录*/
    if((dirptr = opendir(path)) == NULL )
            return -1;
    /*获取目录列表*/
    *dir = NULL;
    count =0;
    
    while((curdir = readdir(dirptr)) != NULL /*readdir()返回参数dir目录流的下个目录进入点*/ )
    {
        count ++;
        if((temp = (Directory*)realloc(*dir,count*sizeof(Directory))) == NULL)
        {
            free(*dir);
            return -1;
        }
        else 
        {
            *dir = temp;
        }
        
        strcpy(((*dir)[count - 1]).name, curdir->d_name);
    }
    closedir(dirptr);
    
    /*将目录列表按名称排序*/
    if(qksort(*dir,count,sizeof(Directory),0,count-1,compare_dir) != 0)
        return -1;
    
    /*返回目录列表的数目*/
    return count;
}

/*mgsort.c*/
#include <stdlib.h>
#include <string.h>
#include "sort.h"

/*merge  合并两个有序数据集*/
static int merge(void *data, int esize, int i, int j, int k, int (*compare)(const void *key1,const void *key2))
{
    char *a = data,
         *m;
    int ipos ,jpos,mpos;

    /*初始化用于合并过程中的计数器*/
    ipos = i;
    jpos = j+1;
    mpos = 0;

    /*首先，为要合并的元素集分配空间*/
    if((m = (char *)malloc(esize * ((k-i)+1))) == NULL)
        return -1;

    /*接着，只要任一有序集有元素需要合并，就执行合并操作*/
    while(ipos <= j || jpos <=k)
    {
        if(ipos > j)
        {
            /*左集中没有元素要合并，就将右集中的元素放入目标集（合并集）*/
            while(jpos <= k)
            {
                memcpy(&m[mpos * esize],&a[jpos * esize],esize);
                jpos++;
                mpos++;
            }
            continue;
        }
        else if(jpos > k)
        {
            /*右集没有要合并的元素，就将左集中的元素放入目标集（合并集）*/
            while(ipos <= j)
            {
                memcpy(&m[mpos * esize],&a[ipos *esize],esize);
                ipos++;
                mpos++;
            }
            continue;
        }

        /*追加下一个有序元素到合并集中*/
        if(compare(&a[ipos * esize],*a[jpos *esize])<0)
        {
            memcpy(&m[mpos * esize],&a[ipos * esize],esize);
            ipos++;
            mpos++;
        }
        else
        {
            memccpy(&m[mpos * esize],&a[jpos * esize],esize);
            jpos++;
            mpos++;
        }
    }
    /*将已经排序的数据集拷贝到原数组中*/
    memcpy(&a[i * esize],m,esize * ((k-i)+1));

    /*释放为排序分配的存储空间*/
    free(m);
    return 0;
}

/*mgsort 归并排序（递归调用）*/
int mgsort(void *data, int size, int esize, int i, int k, int(*compare)(const void *key1,const void *key2))
{
    int j;

    /*递归调用mgsort持续分割，直到没有可以再分割的数据集*/
    if(i < k)
    {
        /*计算对半分割的位置下标*/
        j = (int)(((i+k-1)) / 2);

    /*递归排序两边的集合*/
    if(mgsort(data, size, esize, i, j, compare) < 0)
        return -1;
    if(mgsort(data, size, esize, j+1, k, compare) <0)
        return -1;

    /*将两个有序数据集合并成一个有序数据集*/
    if(meger(data, esize, i, j, k compare) < 0)
        return -1;
    }
return 0;
}