排序算法代码

简介: #include #include #include #if 1//Bubble sortvoid bubble_sort(void *base, size_t num, size_t width, int(*compare)(void*, void*)){ char ...

 

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

#if 1

//Bubble sort
void bubble_sort(void *base, size_t num, size_t width, int(*compare)(void*, void*))
{
    char *temp_data = (char *)malloc(width);    

    if( NULL == base || NULL == compare || NULL == temp_data ) return ;
    if( num < 1 || width < 1 ) { free(temp_data); return ; }for (int j = 0; j < num - 1; j++)   // 每次最大元素就像气泡一样"浮"到数组的最后
    {
        for (int i = 0; i < num - 1 - j; i++)  
        {
            if ( compare((char *)base + i*width, (char *)base + (i+1)*width) > 0 ) 
            {
                // 交换A[i]和A[i+1]
                memcpy(temp_data, (char *)base + i*width, width);
                memcpy((char *)base + (i)*width, (char *)base + (i+1)*width, width);   
                memcpy((char *)base + (i+1)*width, (char *)temp_data, width);  
            }
        }
    }

    free(temp_data);
    return ;
}

//Cocktail shaker sort
void cocktail_sort(void *base, size_t num, size_t width, int(*compare)(void*, void*))
{
    char *temp_data = (char *)malloc(width);    
    int left = 0;  
    int right = num - 1;

    if( NULL == base || NULL == compare || NULL == temp_data ) return ;
    if( num < 1 || width < 1 ) { free(temp_data); return ; }while (left < right)
    {
        for (int i = left; i < right; i++)
        {
            if ( compare((char *)base + i*width, (char *)base + (i+1)*width) > 0 ) 
            {
                // 交换A[i]和A[i+1]
                memcpy(temp_data, (char *)base + i*width, width);
                memcpy((char *)base + (i)*width, (char *)base + (i+1)*width, width);   
                memcpy((char *)base + (i+1)*width, (char *)temp_data, width);  
            }
        }
        right--;
        
        for (int i = right; i > left; i--) 
        {
            if ( compare((char *)base + (i-1)*width, (char *)base + (i)*width) > 0 )                 
            {
                // 交换A[i-1]和A[i]
                memcpy(temp_data, (char *)base + i*width, width);
                memcpy((char *)base + (i)*width, (char *)base + (i-1)*width, width);   
                memcpy((char *)base + (i-1)*width, (char *)temp_data, width);  
            }
        }
        left++;
    }

    free(temp_data);
    return ;
}

//Selection sort
void select_sort(void *base, size_t num, size_t width, int(*compare)(void*, void*))
{
    int i, j, min;
    char *temp_data = (char *)malloc(width);    

    if( NULL == base || NULL == compare || NULL == temp_data ) return ;
    if( num < 1 || width < 1 ) { free(temp_data); return ; }for (i = 0; i <= num - 2; i++)              
    {
        min = i;    
        for (j = i + 1; j <= num - 1; j++)     
        {
            // 依次找出未排序序列中的最小值,存放到已排序序列的末尾
            if ( compare((char *)base + min*width, (char *)base + j*width) > 0 )   
            {
                min = j;
            }
        }
        
        if (min != i)
        {
            // 交换A[min]和A[i]
            memcpy(temp_data, (char *)base + i*width, width);
            memcpy((char *)base + i*width, (char *)base + min*width, width);   
            memcpy((char *)base + min*width, (char *)temp_data, width);  
        }
    }

    free(temp_data);
    return ;
}

//Insertion sort
void insert_sort(void *base, size_t num, size_t width, int(*compare)(void*, void*))
{
    int i, j, get;
    char *temp_data = (char *)malloc(width);    

    if( NULL == base || NULL == compare || NULL == temp_data ) return ;
    if( num < 1 || width < 1 ) { free(temp_data); return ; }for (i = 1; i < num; i++)             
    {
        memcpy(temp_data, (char *)base + i*width, width);
        j = i - 1;                      
        while ( (j >= 0) && (compare((char *)base + j*width, temp_data) > 0 ) ) 
        {
            memcpy((char *)base + (j+1)*width, (char *)base + j*width, width);   
            j--;
        }
        memcpy((char *)base + (j+1)*width, (char *)temp_data, width);
    }

    free(temp_data);
    return ;
}


//Shellsort
void shell_sort(void *base, size_t num, size_t width, int(*compare)(void*, void*))
{
    int i, j, get;
    int h = 0;
    char *temp_data = (char *)malloc(width);    

    if( NULL == base || NULL == compare || NULL == temp_data ) return ;
    if( num < 1 || width < 1 ) { free(temp_data); return ; }while (h <= num)   // 生成初始增量
    {
        h = 3*h + 1;
    }
    while (h >= 1)
    {
        for (i = h; i < num; i++)
        {
            j = i - h;
            memcpy(temp_data, (char *)base + i*width, width);
            while ( (j >= 0) && (compare((char *)base + j*width, temp_data) > 0 ) ) 
            {
                memcpy((char *)base + (j+h)*width, (char *)base + j*width, width);   
                j = j - h;
            }
            memcpy((char *)base + (j+h)*width, temp_data, width);   
        }
        h = (h - 1) / 3; // 递减增量
    }

    free(temp_data);
    return ;
}



#endif

 

测试代码:

#if 1

#include <stdio.h>
#include <stdio.h>

#include <windows.h>

#define ARRAY_SIZE  40960
int my_array[ARRAY_SIZE];

#ifdef WIN32
LARGE_INTEGER t1,t2,feq;
#endif  

int my_cmp(void *data1, void *data2)
{
    int node1 = *(int *)data1;
    int node2 = *(int *)data2;
    return node1 - node2;
}

void print_array(int array[], int print_cnt)
{
    int i;
    
    printf("\r\n ================================================ ");
    for(i = 0; i <= print_cnt; i++) {
        if (i%16 == 0) printf("\r\n");
        printf(" %d", array[i]);
    }
    printf("\r\n ================================================ ");
}

int main()  
{  
    int i;
  
    printf("\r\n init: ");  
    srand(time(NULL));  
    for(i = 0; i < ARRAY_SIZE; i++) {  
        my_array[i] = rand()%ARRAY_SIZE;  
    }  
    print_array(my_array, 64);  
  
    printf("\r\n sort: ");  

#ifdef WIN32
    QueryPerformanceFrequency(&feq);
    QueryPerformanceCounter(&t1);
#endif    
    
    //qsort(array, ARRAY_SIZE, sizeof(int), my_cmp);
    //bubble_sort(my_array, ARRAY_SIZE, sizeof(int), my_cmp);
    //cocktail_sort(my_array, ARRAY_SIZE, sizeof(int), my_cmp);
    //select_sort(my_array, ARRAY_SIZE, sizeof(int), my_cmp);
    //insert_sort(my_array, ARRAY_SIZE, sizeof(int), my_cmp);shell_sort
    shell_sort(my_array, ARRAY_SIZE, sizeof(int), my_cmp);

#ifdef WIN32
    QueryPerformanceCounter(&t2);
    double used_time =((double)t2.QuadPart-(double)t1.QuadPart)/((double)feq.QuadPart);
    printf("%f", used_time);  
#endif    
    
    printf("\r\n show: ");  
    print_array(my_array, 64);  

    printf("\r\n");  
      
    return 0;  
}  
#endif

 

目录
相关文章
|
15天前
|
算法
分享一些提高二叉树遍历算法效率的代码示例
这只是简单的示例代码,实际应用中可能还需要根据具体需求进行更多的优化和处理。你可以根据自己的需求对代码进行修改和扩展。
|
27天前
|
算法 测试技术 开发者
在Python开发中,性能优化和代码审查至关重要。性能优化通过改进代码结构和算法提高程序运行速度,减少资源消耗
在Python开发中,性能优化和代码审查至关重要。性能优化通过改进代码结构和算法提高程序运行速度,减少资源消耗;代码审查通过检查源代码发现潜在问题,提高代码质量和团队协作效率。本文介绍了一些实用的技巧和工具,帮助开发者提升开发效率。
34 3
|
25天前
|
分布式计算 Java 开发工具
阿里云MaxCompute-XGBoost on Spark 极限梯度提升算法的分布式训练与模型持久化oss的实现与代码浅析
本文介绍了XGBoost在MaxCompute+OSS架构下模型持久化遇到的问题及其解决方案。首先简要介绍了XGBoost的特点和应用场景,随后详细描述了客户在将XGBoost on Spark任务从HDFS迁移到OSS时遇到的异常情况。通过分析异常堆栈和源代码,发现使用的`nativeBooster.saveModel`方法不支持OSS路径,而使用`write.overwrite().save`方法则能成功保存模型。最后提供了完整的Scala代码示例、Maven配置和提交命令,帮助用户顺利迁移模型存储路径。
|
2月前
|
存储 缓存 算法
如何通过优化算法和代码结构来提升易语言程序的执行效率?
如何通过优化算法和代码结构来提升易语言程序的执行效率?
|
2月前
|
搜索推荐
插入排序算法的讲解和代码
【10月更文挑战第12天】插入排序是一种基础的排序算法,理解和掌握它对于学习其他排序算法以及数据结构都具有重要意义。你可以通过实际操作和分析,进一步深入了解插入排序的特点和应用场景,以便在实际编程中更好地运用它。
|
4月前
|
机器学习/深度学习 人工智能 自然语言处理
【自然语言处理】TF-IDF算法在人工智能方面的应用,附带代码
TF-IDF算法在人工智能领域,特别是自然语言处理(NLP)和信息检索中,被广泛用于特征提取和文本表示。以下是一个使用Python的scikit-learn库实现TF-IDF算法的简单示例,并展示如何将其应用于文本数据。
266 65
|
2月前
|
缓存 分布式计算 监控
优化算法和代码需要注意什么
【10月更文挑战第20天】优化算法和代码需要注意什么
18 0
|
2月前
|
算法 Java 测试技术
数据结构 —— Java自定义代码实现顺序表,包含测试用例以及ArrayList的使用以及相关算法题
文章详细介绍了如何用Java自定义实现一个顺序表类,包括插入、删除、获取数据元素、求数据个数等功能,并对顺序表进行了测试,最后还提及了Java中自带的顺序表实现类ArrayList。
23 0
|
3月前
|
机器学习/深度学习 存储 算法
经典算法代码
这段代码展示了多个经典算法,包括:穷举法解决“百钱买百鸡”问题;递推法计算“猴子吃桃”问题;迭代法求解斐波那契数列及折纸高度超越珠峰的问题。同时,还提供了希尔排序算法实现及披萨票务订购系统和汉诺塔问题的链表存储解决方案。每部分通过具体案例解释了算法的应用场景与实现方法。
31 3
|
4月前
|
机器学习/深度学习 人工智能 算法
【人工智能】传统语音识别算法概述,应用场景,项目实践及案例分析,附带代码示例
传统语音识别算法是将语音信号转化为文本形式的技术,它主要基于模式识别理论和数学统计学方法。以下是传统语音识别算法的基本概述
82 2
下一篇
无影云桌面