通用动态数组(三)——算法排序

最新推荐文章于 2024-07-22 15:15:29 发布
最新推荐文章于 2024-07-22 15:15:29 发布
阅读量75 收藏
点赞数
文章标签： python
原文链接：https://my.oschina.net/mavericsoung/blog/217829
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

/*************************************sort.h****************************/
#ifndef SORT_H
#define SORT_H

#include "type.h"

#ifdef __cplusplus
    extern "C"{
#endif

/*basic---complex:O(n*n)*/
Ret bubble_sort(void** array, size_t nr,  DataCompareFunc cmp);
Ret select_sort(void** array, size_t nr, DataCompareFunc cmp);
Ret insert_sort(void** array, size_t nr, DataCompareFunc cmp);

/*shell---complex:<O(n*n)*/
Ret shell_sort(void** array, size_t nr, DataCompareFunc cmp);

/*quick---complex:O(nlogn)*/
Ret quick_sort(void** array, size_t nr,  DataCompareFunc cmp);

/*merge*/
Ret merge_sort(void** array, size_t nr,  DataCompareFunc cmp);

/*heap*/
Ret heap_sort(void** array, size_t nr,  DataCompareFunc cmp);


#ifdef __cplusplus
    }
#endif

#endif
/***************************************sort.c*****************************************/
#include "sort.h"

Ret bubble_sort(void** array, size_t nr,  DataCompareFunc cmp)
{
    size_t i = 0;
    size_t j = 0;
    
    void* data = 0;

    return_val_if_fail(array != NULL && cmp != NULL, RET_INVALID_PARAMETER);

    for(i = 0; i < nr -1; i++)
    {        
        for(j = 0; j < (nr-1-i); j++)
        {
            if(cmp(array[j], array[j+1]) > 0)
            {
                data = array[j];
                array[j] = array[j+1];
                array[j+1] = data;
            }
        }                
    }
        
    return RET_OK;
}

Ret select_sort(void** array, size_t nr, DataCompareFunc cmp)
{
    size_t i = 0;
    size_t j = 0;
    size_t min = 0;
    void* data = 0;

    return_val_if_fail(array != NULL && cmp != NULL, RET_INVALID_PARAMETER);

    for(i = 0; i < nr; i++)
    {
        min = i;
        for(j = i+1; j < nr; j++)
        {
            if(cmp(array[j], array[min]) < 0)
            {
                min = j;
            }
        }

        if(min != i)
        {
            data = array[i];
            array[i] = array[min];
            array[min] = data;
        }
    }

    return RET_OK;
}

Ret insert_sort(void** array, size_t nr, DataCompareFunc cmp)
{
    size_t i = 0;
    size_t j = 0;
    void* data = 0;
    
    return_val_if_fail(array != NULL && cmp != NULL, RET_INVALID_PARAMETER);

    //choose the smallest elemnt as sentinel key and store into array[0]
    for(i = nr - 1; i > 0; i--)
    {
        if(cmp(array[i], array[i-1]) < 0)
        {
            data = array[i-1];
            array[i-1] = array[i];
            array[i] = data;
        }
    }

    for(i = 2; i < nr; i++)
    {
        j = i;
        data = array[i];
                
        while(cmp(data, array[j-1]) < 0)
        {
            array[j] = array[j-1];
            j--;            
        }

        array[j] = data;        
    }

    return RET_OK;
}

Ret shell_sort(void** array, size_t nr, DataCompareFunc cmp)
{
    size_t i = 0;
    size_t j = 0;
    size_t h = 0;
    void *data = 0;

    return_val_if_fail(array != NULL && cmp != NULL, RET_INVALID_PARAMETER);

    //generate max grap h value
    for(h = 1; h < (nr-1)/9; h = 3*h+1);

    //append a cycle on the base  of basic insert sort
    for(; h > 0; h /= 3)
    {
        for(i = h; i < nr; i++)
        {
            j = i;
            data = array[i];

            while(j >= h && cmp(data, array[j-h]) < 0)
            {
                array[j] = array[j-h];
                j -= h;
            }
            
            array[j] = data;
        }
    }

    return RET_OK;
}

static void quick_sort_implement(void** array, size_t low, size_t high, DataCompareFunc cmp)
{
    size_t save_low = low;
    size_t save_high = high;
    void *data = array[low];
            
    /*move item that less than data to left, otherwise to right*/
    while(low < high)
    {
        while(cmp(array[high], data) >= 0 && (low < high)) high--;
        if(low != high)
        {
            array[low] = array[high];
            low++;
        }

        while(cmp(array[low], data) <= 0 && (low < high)) low++;
        if(low != high)
        {
            array[high] = array[low];
            high--;
        }
    }

    array[low] = data;
    
    /*left partion sort*/
    if(save_low < low)
    {
        quick_sort_implement(array, save_low, low-1, cmp);
    }

    /*right partion sort*/
    if(save_high > high)
    {
        quick_sort_implement(array, low+1, save_high, cmp);
    }

    return;
}

Ret quick_sort(void** array, size_t nr,  DataCompareFunc cmp)
{
    return_val_if_fail(array != NULL && cmp != NULL, RET_INVALID_PARAMETER);

    if(nr > 1)
    {
        quick_sort_implement(array, 0, nr-1, cmp);
    }
    
    return RET_OK;
}

static Ret merge_sort_implement(void** storage, void** array, size_t low, size_t mid, size_t high, DataCompareFunc cmp)
{
    size_t i = low; //all part
    size_t j = low; //left part
    size_t k = mid; //right part

    /*merge left part*/
    if((low+1) < mid)
    {
        size_t x = low + ((mid-low)>>1);
        merge_sort_implement(storage, array, low, x, mid, cmp);
    }

    /*merge right part*/
    if((mid+1) < high)
    {
        size_t x = mid + ((high-mid)>>1);
        merge_sort_implement(storage, array, mid, x, high, cmp);
    }

    /*merge two sequece part*/
    while(j < mid && k < high)
    {
        if(cmp(array[j], array[k]) <= 0)
        {
            storage[i++] = array[j++];
        }
        else
        {
            storage[i++] = array[k++];
        }
    }

    while(j < mid)
    {
        storage[i++] = array[j++];
    }

    while(k < high)
    {
        storage[i++] = array[k++];
    }

    for(i = low; i < high; i++)
    {
        array[i] = storage[i];
    }

    return RET_OK;
}

Ret merge_sort(void** array, size_t nr,  DataCompareFunc cmp)
{
    Ret ret = RET_FAIL;
    void** storage = NULL;

    return_val_if_fail(array != NULL && cmp != NULL, RET_INVALID_PARAMETER);

    if(nr > 1)
    {
        storage = (void**)malloc(sizeof(void *) * nr);
        if(storage == NULL)
        {
            ret = RET_OOM;
        }
        else
        {
            ret = merge_sort_implement(storage, array, 0, nr>>1, nr, cmp);
            free(storage);
            storage = NULL;
        }
    }

    return ret;           
}


static void heap_adjust(void** array, size_t index, size_t nr, DataCompareFunc cmp)
{
    size_t j = 0;
    void* data = array[index];

    for(j = 2 * index; j <= nr; j *= 2)
    {

        if(j < nr && cmp(array[j], array[j+1]) < 0)
        {
            j++;
        }

        /*max heap*/
        if(cmp(data, array[j]) > 0)
        {
            break;
        }

        array[index] = array[j];
        index = j;        
    }

    array[index] = data;    
    
    return;
}

Ret heap_sort(void** array, size_t nr,  DataCompareFunc cmp)
{    
    size_t i;
    void* data;
    void** parray;
    Ret ret = RET_OK;

    return_val_if_fail( array != NULL && cmp != NULL, RET_INVALID_PARAMETER);
    

    if(nr > 1)
    {
        /*
         *adapt array like this way a[1]..a[n] 
         *in order to use the adjust algrith
         */
        parray = array - 1;//parray[1] == array[0]   

        /*create max top heap and start to adjust from array[n/2]*/
        for( i = (nr >> 1); i > 0; i--)
        {
            heap_adjust(parray, i, nr, cmp);
        }

        /*
         *exchange heap top value and tail value, and
         *adjust the left in cycle until heap is null.
         */
        for(i = nr; i > 1; --i)
        {
            data = parray[1];  //max value == top value
            parray[1] = parray[i];
            parray[i] = data;
            
            heap_adjust(parray, 1, i-1, cmp);
        } 
    }

    return ret;
}
/*****************************sort_test.c*******************************************/
#include "darray.h"
#include "sort.h"
#include "test_helper.c"

//#define BUBBLE_SORT
//#define INSERT_SORT
//#define SHELL_SORT
//#define QUICK_SORT
//#define MERGE_SORT
#define HEAP_SORT

static void sort_test()
{
    int i = 0;
    int data[] = {2, 4, 1, 6, 3, 3, 4, 5, 7, 8, 9, 0,12,13,11};    
    //int data[] = {49, 38, 65, 97 ,76, 13, 27, 49};    
    int num = sizeof(data) / sizeof(*data);
    DArray* this = NULL;
    
    this = darray_create(NULL, NULL);
    if(NULL == this)
    {
        return;    
    }

    for(i = 0; i < num; i++)
    {
       assert(darray_append(this, (void* )data[i]) == RET_OK);
    }

    assert(darray_length(this) == num);    

    assert(darray_foreach(this, print_int, NULL) == RET_OK);                       
    printf("\n");

    #if defined (BUBBLE_SORT)    
    assert(darray_sort(this, (DataSortFunc)bubble_sort, int_cmp) ==  RET_OK); 
    #elif defined(INSERT_SORT)    
    assert(darray_sort(this, (DataSortFunc)insert_sort, int_cmp) ==  RET_OK); 
    #elif defined(SHELL_SORT)    
    assert(darray_sort(this, (DataSortFunc)shell_sort, int_cmp) ==  RET_OK); 
    #elif defined(QUICK_SORT)
    assert(darray_sort(this, (DataSortFunc)quick_sort, int_cmp) ==  RET_OK); 
    #elif defined(MERGE_SORT)
    assert(darray_sort(this, (DataSortFunc)merge_sort, int_cmp) ==  RET_OK); 
    #elif defined(HEAP_SORT)
    assert(darray_sort(this, (DataSortFunc)heap_sort, int_cmp) ==  RET_OK);     
    #endif
        
    assert(darray_foreach(this, print_int, NULL) == RET_OK);                       
    printf("\n");
    darray_destroy(this);
        
}

int main()
{
    sort_test();
    return 0;
}


转载于:https://my.oschina.net/mavericsoung/blog/217829

weixin_34291004
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++简单排序——冒泡排序
小天狼星_布莱克 的博客
06-25 2万+
冒泡排序，简单的排序方法，C++，适合初学者
postgresql 发生 oom 的分析之二 cgroup
weixin_30596165的博客
08-24 387
os:centos 7.4 postgresql:10.4 接上一篇blog：postgresql 发生 oom 的分析之一 本 blog 使用 cgroup 控制 os 的 memory，先简单介绍下cgroups： CGroups 是一种对进程资源管理和控制的统一框架，它提供的是一种机制，而具体的策略（Policy）是通过子系统（subs...
编写一个使用数组类模板Array对数组进行排序、求最大值和求元素和的程序，并采用相关数据进行测试。
u012653518的专栏
12-08 9528
#include using namespace std; template class Array{ private: T *elem; int size; public: Array(int a[],int s):elem(a),size(s){} T Max(); T Sum(); void Sort(); void Display(); };   templa
动态数组的排序问题
weixin_44011791的博客
12-08 1791
输入一行数字，如果我们把这行数字中的‘5’都看成空格，那么就得到一行用空格分割的若干非负整数（可能有些整数以‘0’开头，这些头部的‘0’应该被忽略掉，除非这个整数就是由若干个‘0’组成的，这时这个整数就是0）。 你的任务是：对这些分割得到的整数，依从小到大的顺序排序输出。 #include "pch.h" #include &lt;iostream&gt; #include&lt;cstring&...
linux下的oom调试笔记【原创】
09-01 206
平台信息:内核：linux3.0.68系统：android/android5.1平台：s5p4418 作者：庄泽彬(欢迎转载，请注明作者) 邮箱：2760715357@qq.com 摘要:调整android系统的init.rc文件中开启服务的oom的值，使之可以被杀死。 首先：我们来做一下实验，在android系统的init.rc文件中添加一个服务。这个服务只做一件事情不断的申...
系统程序员成长计划-动态数组（三）（下）
国产开源 GUI 引擎 AWTK
02-13 4662
 转载时请注明出处和作者联系方式文章出处：http://www.limodev.cn/blog作者联系方式：李先静 排序对于前面提的两点额外要求：o 算法同时支持升序和降序。o 算法同时支持多种数据类型。只要认真阅读过前面章节的读者，马上会想到用回调函数。这是对的。软件设计的关键在于熟能生巧，我们反复练习这些基本技巧也意在于此。熟到凭本能就可以运用正确的方法时，那也
排序算法——基本排序算法
新生代程序“猿”的博客
08-03 641
Java的一些简单排序算法
几种常用对象数组的排序算法——java语言描述
Rango_kjc的博客
08-04 573
常用的排序算法有 1 选择排序 2 插入排序 3 希尔排序 4 冒泡排序 5 归并排序 6 快速排序 7 堆排序 8 基数排序 1 选择排序 原理 对一个数组a来说，选择排序先找到数组最小的项，将它与a[0]交换。然后，忽略a[0]，找到下一个最小的项并交换到 a[1]，以此类推。图1-1显示了如何利用选择排序通过交换值完成对...
C语言数据结构——常见排序算法（一）
wxk2227814847的博客
03-30 1001
排序是计算机科学中最基础也是最重要的算法之一。在数据处理过程中，将数据集按照一定的顺序重新排列的过程称为排序。排序算法的研究，不仅能够提高我们解决问题的效率，而且对于理解数据结构与算法的设计思想具有重要意义。
数据结构与算法——排序
07-05
本文将深入探讨在标题和描述中提及的几种排序算法：快速排序、堆排序和希尔排序，以及另外两种基础排序方法——插入排序和选择排序，以及冒泡排序。 1. **快速排序**：由C.A.R. Hoare在1960年提出，快速排序是一种...
数据结构、算法与应用——C++语言描述.rar
07-25
书中讲解了排序（如冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等）、查找（线性查找、二分查找、哈希查找）、图论（深度优先搜索、广度优先搜索、最短路径算法如Dijkstra和Floyd-Warshall）、动态...
算法设计与分析——习题6.35答案
05-20
然而，由于它并不保证整个数组的排序，所以它不能被视为一个通用的排序算法。在实际应用中，这种“部分排序”可能在预处理数据、过滤负数或实现特定逻辑时派上用场。 分析算法的时间复杂度，我们可以看到，每个元素...
详细的排序算法演示和继承
11-09
这不仅有助于学习者了解算法的逻辑，也能帮助他们理解继承如何在实际项目中应用，比如，一个基础的排序类可能包含通用的排序功能，而其他特定的排序类（如快速排序类）则继承自这个基础类，添加自己的特性和优化。...
【Python如何将字符串连接在一起并使用`join()`方法】
qq_36253366的博客
07-19 415
方法是字符串对象的方法，而不是列表或元组等序列类型的方法。因此，你需要先指定一个用作分隔符的字符串，然后调用这个字符串的。方法将字符串连接在一起，你需要首先确保这些字符串被存储在一个序列类型中（如列表或元组），然后调用这个序列的。方法是一个字符串方法，它用于将序列（如列表、元组等）中的元素以指定的字符连接生成一个新的字符串。列表中的所有字符串元素使用空格作为分隔符连接成一个新的字符串。方法，并将你想要作为分隔符的字符串作为参数传递给。方法，并将包含要连接字符串的序列作为参数传递。
【影刀】自动化办公介绍与RPA机器人实例
最新发布
weixin_44195690的博客
07-22 123
影刀RPA是杭州分叉智能科技有限公司开发的一款自动化办公软件。它是基于Machine Behavior Learning(机器行为学习)技术，为各行业提供行为自动化办公机器人。
【Python 中的内存管理有哪些优缺点】
qq_36253366的博客
07-19 406
Python中的内存管理是一个复杂而高效的系统，它通过自动化和抽象化的方式极大地简化了程序员的内存管理负担，但同时也存在一些潜在的缺点。
批量下载网易云音乐歌单的Python脚本
qq_43580271的博客
07-17 1296
同时，这也展示了如何利用Python在日常生活中解决实际问题的能力，希望这个小技巧对你有所帮助！
python训练模型报错：BrokenPipeError: [Errno 32] Broken pipe
Dxy1239310216的博客
07-18 480
如果问题持续存在，并且你的项目不是必须在 Windows 上运行，考虑在 Unix/Linux 系统上运行你的代码。确保在数据加载器中使用的任何自定义函数或类都是可序列化的，因为多进程需要能够在不同进程间传递它们。进行多进程数据加载时尤其常见，尤其是在 Windows 系统上，因为 Windows 对多进程的支持与 Unix/Linux 系统有所不同。有时候，错误可能是由其他部分的代码引起的，而不是直接由数据加载器引起。如果问题依然存在，你可能需要更详细地检查你的代码或寻求更专业的帮助。
白骑士的PyCharm教学目录
JeremyTC的博客
07-19 313
白骑士的PyCharm教学目录，点击超链接跳转对应文章
STL序列式容器详解：向动态数组学习
3. 算法（Algorithms）：STL提供了大量的内置算法，如排序、搜索、集合操作等，这些算法可以应用于各种容器，无需关心底层实现细节，提高了代码的复用性和可读性。 4. 配接器（Adaptors）：这些是针对已有的容器或...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值