浅析uthash系列之五：链表排序（list sort）

最新推荐文章于 2023-07-26 14:13:45 发布
原创 最新推荐文章于 2023-07-26 14:13:45 发布 · 2.3k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细解析了uthash库中的链表排序算法，该算法采用分治策略，复杂度为O(n log(n))。通过多次迭代，将无序链表转化为有序链表。文章通过示例代码展示了排序过程，从单个元素有序链表逐步合并成完整有序链表。

链表排序

uthash版本 :2.0.2
作者：jafon.tian
转载请注明出处：https://blog.youkuaiyun.com/JT_Notes

排序API宏

uthash提供了宏用于hash表中元素的排序

API名称参数与说明
HASH_SORT(head,cmpfcn)
head：hash表头；cmpfcn：元素比较函数

排序算法

uthash采用了分治算法，算法复杂度为O(n log(n))。算法的基本原理是递归，每一次递归都将输入链表当成是规模小一些的有序链表的连接组合。排序过程会遍历log(n)次整个链表，每次遍历都会将相邻的两个有序链表组成一个有序链表，最后就产生了一个完整的有序链表。
HASH_SORT的实现的妙处在于并未使用递归调用，而是反其道行之，从只包含一个元素的有序链表开始，生成包含两个元素的有序链表，然后生成包含四个元素的有序链表，最后得到整个有序链表。

下面是排序源码，为了能直观看出每次排序的变化，进行了一点调整，再输入参数中增加了pfcn打印函数，每次排序结束都会将链表头作为参数传给pfcn。

#define HASH_SORT_P(head, cmpfcn, pfcn) HASH_SRT_P(hh, head, cmpfcn, pfcn)
#define HASH_SRT_P(hh, head, cmpfcn, pfcn)                                                          \
  do                                                                                                \
  {                                                                                                 \
    unsigned _hs_i;                                                                                 \
    unsigned _hs_looping, _hs_nmerges, _hs_insize, _hs_psize, _hs_qsize;                            \
    struct UT_hash_handle *_hs_p, *_hs_q, *_hs_e, *_hs_list, *_hs_tail;                             \
    if (head != NULL)                                                                               \
    {                                                                                               \
      _hs_insize = 1;                                                                               \
      _hs_looping = 1;                                                                              \
      _hs_list = &((head)->hh);                                                                     \
      while (_hs_looping != 0U)                                                                     \
      {                                                                                             \
        _hs_p = _hs_list;                                                                           \
        _hs_list = NULL;                                                                            \
        _hs_tail = NULL;                                                                            \
        _hs_nmerges = 0;                                                                            \
        while (_hs_p != NULL)                                                                       \
        {                                                                                           \
          _hs_nmerges++;                                                                            \
          _hs_q = _hs_p;                                                                            \
          _hs_psize = 0;                                                                            \
          for (_hs_i = 0; _hs_i < _hs_insize; ++_hs_i)                                              \
          {                                                                                         \
            _hs_psize++;                                                                            \
            _hs_q = ((_hs_q->next != NULL) ? HH_FROM_ELMT((head)->hh.tbl, _hs_q->next) : NULL);     \
            if (_hs_q == NULL)                                                                      \
            {                                                                                       \
              break;                                                                                \
            }                                                                                       \
          }                                                                                         \
          _hs_qsize = _hs_insize;                                                                   \
          while ((_hs_psize != 0U) || ((_hs_qsize != 0U) && (_hs_q != NULL)))                       \
          {                                                                                         \
            if (_hs_psize == 0U)                                                                    \
            {                                                                                       \
              _hs_e = _hs_q;                                                                        \
              _hs_q = ((_hs_q->next != NULL) ? HH_FROM_ELMT((head)->hh.tbl, _hs_q->next) : NULL);   \
              _hs_qsize--;                                                                          \
            }                                                                                       \
            else if ((_hs_qsize == 0U) || (_hs_q == NULL))                                          \
            {                                                                                       \
              _hs_e = _hs_p;                                                                        \
              if (_hs_p != NULL)                                                                    \
              {                                                                                     \
                _hs_p = ((_hs_p->next != NULL) ? HH_FROM_ELMT((head)->hh.tbl, _hs_p->next) : NULL); \
              }                                                                                     \
              _hs_psize--;                                                                          \
            }                                                                                       \
            else if ((cmpfcn(                                                                       \
                         DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl, _hs_p)),                       \
                         DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl, _hs_q)))) <= 0)                \
            {                                                                                       \
              _hs_e = _hs_p;                                                                        \
              if (_hs_p != NULL)                                                                    \
              {                                                                                     \
                _hs_p = ((_hs_p->next != NULL) ? HH_FROM_ELMT((head)->hh.tbl, _hs_p->next) : NULL); \
              }                                                                                     \
              _hs_psize--;                                                                          \
            }                                                                                       \
            else                                                                                    \
            {                                                                                       \
              _hs_e = _hs_q;                                                                        \
              _hs_q = ((_hs_q->next != NULL) ? HH_FROM_ELMT((head)->hh.tbl, _hs_q->next) : NULL);   \
              _hs_qsize--;                                                                          \
            }                                                                                       \
            if (_hs_tail != NULL)                                                                   \
            {                                                                                       \
              _hs_tail->next = ((_hs_e != NULL) ? ELMT_FROM_HH((head)->hh.tbl, _hs_e) : NULL);      \
            }                                                                                       \
            else                                                                                    \
            {                                                                                       \
              _hs_list = _hs_e;                                                                     \
            }                                                                                       \
            if (_hs_e != NULL)                                                                      \
            {                                                                                       \
              _hs_e->prev = ((_hs_tail != NULL) ? ELMT_FROM_HH((head)->hh.tbl, _hs_tail) : NULL);   \
            }                                                                                       \
            _hs_tail = _hs_e;                                                                       \
          }                                                                                         \
          _hs_p = _hs_q;                                                                            \
        }                                                                                           \
        if (_hs_tail != NULL)                                                                       \
        {                                                                                           \
          _hs_tail->next = NULL;                                                                    \
        }                                                                                           \
        if (_hs_nmerges <= 1U)                                                                      \
        {                                                                                           \
          _hs_looping = 0;                                                                          \
          (head)->hh.tbl->tail = _hs_tail;                                                          \
          DECLTYPE_ASSIGN(head, ELMT_FROM_HH((head)->hh.tbl, _hs_list));                            \
        }                                                                                           \
        _hs_insize *= 2U;                                                                           \
        pfcn(DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl, _hs_list)));                               \
      }                                                                                             \
      HASH_FSCK(hh, head, "HASH_SRT_P");                                                            \
    }                                                                                               \
  } while (0)

使用示例

示例使用tests/test11.c，不过为了演示方便，进行了一些调整。源码如下

#include "uthash.h" //增加了HASH_SORT_P
#include <stdlib.h>   /* malloc */
#include <errno.h>    /* perror */
#include <stdio.h>    /* printf */

#define BUFLEN 20

#if 0
/* Print a message if the hash's no-expand flag is set. */
#undef uthash_noexpand_fyi
#undef uthash_expand_fyi
#define uthash_noexpand_fyi(tbl) printf("noexpand set\n");
#define uthash_expand_fyi(tbl) printf("hash expanded\n");
#endif

typedef struct name_rec {
    char boy_name[BUFLEN];
    UT_hash_handle hh;
} name_rec;

static int namecmp(void *_a, void *_b)
{
    name_rec *a = (name_rec*)_a;
    name_rec *b = (name_rec*)_b;
    return strcmp(a->boy_name,b->boy_name);
}

static void printel(void *namelist)
{
    char boy_name[BUFLEN];
    int n_inx;
    name_rec *name = (name_rec*)namelist;
    for(; name!=NULL; (name = (name_rec*)(name->hh.next)) ? printf(" <=> "):printf("\n\n")) {
        sprintf(boy_name, "%s", name->boy_name);
        n_inx = strlen(boy_name);
        if(n_inx > 0)
            boy_name[n_inx-1] = '\0';
        printf("%s", boy_name);
    }
}

int main(int argc,char *argv[])
{
    name_rec *name, *names=NULL;
    char linebuf[BUFLEN];
    FILE *file;

    file = fopen( "test11.dat", "r" );
    if (file == NULL) {
        perror("can't open: ");
        exit(-1);
    }

    while (fgets(linebuf,BUFLEN,file) != NULL) {
        name = (name_rec*)malloc(sizeof(name_rec));
        if (name == NULL) {
            exit(-1);
        }
        strcpy(name->boy_name, linebuf);
        HASH_ADD_STR(names,boy_name,name);
    }

    fclose(file);
    printel(names);
    HASH_SORT_P(names,namecmp,printel);

    return 0;
}

编译test11.c，并运行

gcc -I../src -o test11 test11.c 
./test11

下面对输出进行说明

  • 原始序列，一共是51个无序英文名

JOHN <=> WILLIAM <=> WALTER <=> DOUGLAS <=> GERALD <=> FREDERICK <=> WARREN <=> SHANE <=> LESTER <=> RON <=> HARVEY <=> ADRIAN <=> CODY <=> NELSON <=> CLIFTON <=> WILLARD <=> DOUG <=> ORLANDO <=> REX <=> OMAR <=> DAMON <=> LOWELL <=> IRVING <=> CARROLL <=> LAURENCE <=> ROLANDO <=> CARY <=> XAVIER <=> ISAIAH <=> GUS <=> JARVIS <=> WINFRED <=> RAYMUNDO <=> LINCOLN <=> CORNELL <=> NIGEL <=> NORMAND <=> FRITZ <=> DONN <=> TRINIDAD <=> ODIS <=> DANNIE <=> DARIO <=> KENTON <=> CHONG <=> NEVILLE <=> TONEY <=> WARNER <=> WES <=> COLTON <=> ARNOLDO

  • 第1次排序之后，原始序列变成了以两个元素为一组的有序序列，比如第3和第4个英文名组成的两元素链表由之前的WALTER <=> DOUGLAS变成了DOUGLAS <=> WALTER。

JOHN <=> WILLIAM <=> DOUGLAS <=> WALTER <=> FREDERICK <=> GERALD <=> SHANE <=> WARREN <=> LESTER <=> RON <=> ADRIAN <=> HARVEY <=> CODY <=> NELSON <=> CLIFTON <=> WILLARD <=> DOUG <=> ORLANDO <=> OMAR <=> REX <=> DAMON <=> LOWELL <=> CARROLL <=> IRVING <=> LAURENCE <=> ROLANDO <=> CARY <=> XAVIER <=> GUS <=> ISAIAH <=> JARVIS <=> WINFRED <=> LINCOLN <=> RAYMUNDO <=> CORNELL <=> NIGEL <=> FRITZ <=> NORMAND <=> DONN <=> TRINIDAD <=> DANNIE <=> ODIS <=> DARIO <=> KENTON <=> CHONG <=> NEVILLE <=> TONEY <=> WARNER <=> COLTON <=> WES <=> ARNOLDO

  • 第2次排序之后，序列变成了以四个元素为一组的有序序列。

DOUGLAS <=> JOHN <=> WALTER <=> WILLIAM <=> FREDERICK <=> GERALD <=> SHANE <=> WARREN <=> ADRIAN <=> HARVEY <=> LESTER <=> RON <=> CLIFTON <=> CODY <=> NELSON <=> WILLARD <=> DOUG <=> OMAR <=> ORLANDO <=> REX <=> CARROLL <=> DAMON <=> IRVING <=> LOWELL <=> CARY <=> LAURENCE <=> ROLANDO <=> XAVIER <=> GUS <=> ISAIAH <=> JARVIS <=> WINFRED <=> CORNELL <=> LINCOLN <=> NIGEL <=> RAYMUNDO <=> DONN <=> FRITZ <=> NORMAND <=> TRINIDAD <=> DANNIE <=> DARIO <=> KENTON <=> ODIS <=> CHONG <=> NEVILLE <=> TONEY <=> WARNER <=> ARNOLDO <=> COLTON <=> WES

  • 第3次排序之后，序列变成了以八个元素为一组的有序序列。

DOUGLAS <=> FREDERICK <=> GERALD <=> JOHN <=> SHANE <=> WALTER <=> WARREN <=> WILLIAM <=> ADRIAN <=> CLIFTON <=> CODY <=> HARVEY <=> LESTER <=> NELSON <=> RON <=> WILLARD <=> CARROLL <=> DAMON <=> DOUG <=> IRVING <=> LOWELL <=> OMAR <=> ORLANDO <=> REX <=> CARY <=> GUS <=> ISAIAH <=> JARVIS <=> LAURENCE <=> ROLANDO <=> WINFRED <=> XAVIER <=> CORNELL <=> DONN <=> FRITZ <=> LINCOLN <=> NIGEL <=> NORMAND <=> RAYMUNDO <=> TRINIDAD <=> CHONG <=> DANNIE <=> DARIO <=> KENTON <=> NEVILLE <=> ODIS <=> TONEY <=> WARNER <=> ARNOLDO <=> COLTON <=> WES

  • 第4次排序之后，序列变成了以十六个元素为一组的有序序列。

ADRIAN <=> CLIFTON <=> CODY <=> DOUGLAS <=> FREDERICK <=> GERALD <=> HARVEY <=> JOHN <=> LESTER <=> NELSON <=> RON <=> SHANE <=> WALTER <=> WARREN <=> WILLARD <=> WILLIAM <=> CARROLL <=> CARY <=> DAMON <=> DOUG <=> GUS <=> IRVING <=> ISAIAH <=> JARVIS <=> LAURENCE <=> LOWELL <=> OMAR <=> ORLANDO <=> REX <=> ROLANDO <=> WINFRED <=> XAVIER <=> CHONG <=> CORNELL <=> DANNIE <=> DARIO <=> DONN <=> FRITZ <=> KENTON <=> LINCOLN <=> NEVILLE <=> NIGEL <=> NORMAND <=> ODIS <=> RAYMUNDO <=> TONEY <=> TRINIDAD <=> WARNER <=> ARNOLDO <=> COLTON <=> WES

  • 第5次排序之后，序列变成了以三十二个元素为一组的有序序列。

ADRIAN <=> CARROLL <=> CARY <=> CLIFTON <=> CODY <=> DAMON <=> DOUG <=> DOUGLAS <=> FREDERICK <=> GERALD <=> GUS <=> HARVEY <=> IRVING <=> ISAIAH <=> JARVIS <=> JOHN <=> LAURENCE <=> LESTER <=> LOWELL <=> NELSON <=> OMAR <=> ORLANDO <=> REX <=> ROLANDO <=> RON <=> SHANE <=> WALTER <=> WARREN <=> WILLARD <=> WILLIAM <=> WINFRED <=> XAVIER <=> ARNOLDO <=> CHONG <=> COLTON <=> CORNELL <=> DANNIE <=> DARIO <=> DONN <=> FRITZ <=> KENTON <=> LINCOLN <=> NEVILLE <=> NIGEL <=> NORMAND <=> ODIS <=> RAYMUNDO <=> TONEY <=> TRINIDAD <=> WARNER <=> WES

  • 第6次排序之后，序列变成了完整的有序序列。

ADRIAN <=> ARNOLDO <=> CARROLL <=> CARY <=> CHONG <=> CLIFTON <=> CODY <=> COLTON <=> CORNELL <=> DAMON <=> DANNIE <=> DARIO <=> DONN <=> DOUG <=> DOUGLAS <=> FREDERICK <=> FRITZ <=> GERALD <=> GUS <=> HARVEY <=> IRVING <=> ISAIAH <=> JARVIS <=> JOHN <=> KENTON <=> LAURENCE <=> LESTER <=> LINCOLN <=> LOWELL <=> NELSON <=> NEVILLE <=> NIGEL <=> NORMAND <=> ODIS <=> OMAR <=> ORLANDO <=> RAYMUNDO <=> REX <=> ROLANDO <=> RON <=> SHANE <=> TONEY <=> TRINIDAD <=> WALTER <=> WARNER <=> WARREN <=> WES <=> WILLARD <=> WILLIAM <=> WINFRED <=> XAVIER

JT_Notes
关注
BAT 大厂Java 面试题集锦之核心篇附参考答案
AI天才研究院
11-05 1万+
核心篇数据结构与算法网路:TCP/IP,HTTP操作系统, 文件, shell, CPU, IO, epoll, 非阻塞IO,进程/线程/协程,锁HashMap, Co...
浅析Redis技术
ZY-JIMMY
08-02 2271
Redis简介、Redis事务、Redis的五种数据类型、Redis常见性能问题和解决方案
浅析uthash系列之四：uthash扩张（expand buckets）
JT_Notes的博客
08-03 1640
uthash的扩张 uthash版本 :2.0.2 作者：jafon.tian 转载请注明出处：https://blog.youkuaiyun.com/JT_Notes 什么是扩张？ uthash作为一种hash表的实现方式，必须力求随着表中元素个数的增多，表操作的性能尽量保持某个常量。为了满足要求，uthash设计了bucket结构。将元素添加到hash表的时候，先对元素key进行hash运算...
浅析uthash系列之User Guide（翻译）
JT_Notes的博客
07-25 4142
uthash用户指引   作者：Troy D. Hanson, Arthur O'Dwyer 翻译：jafon.tian 转载请注明出处：https://blog.youkuaiyun.com/JT_Notes   下载uthash，请点击此链接至GitHub项目页面。   C语言的hash（A hash in C） 这份文档是写给C程序员们的。既然你来到了这里，相信你应该知道当需要使用ke...
哈希表排序
henulmh的博客
05-20 2374
运用哈希表排序时，所使用的参数是Map.Entry<key,value> Map.Entry是Map接口中的一个内部接口，这个接口的对象中包含了K和V； 获取K的方式是Map.Entry对象名.getKey()，获取V的方式是Map.Entry对象名.getValue(); // 先按照value升序 再按照key降序的排序规则 class px implements Comparator<Map.Entry<String,Integer>>{ public int c
hash+链表排序
Vibrant
06-11 331
这道题真的出得跟shi一样
排序 链表c语言程序,[原创]桶排序 链表 hash C语言实现
weixin_36008052的博客
05-18 162
思路：将数放到桶内，先将桶内排序，再整体排序。用链表数组表示桶，然后用(元素值 + k)/(k+1)来定位插入哪个桶里k 个桶，最后一个桶用来放最大值，只有 k - 1 个跨度，这 k - 1 个跨度对应 k - 1 个桶。数对应的桶的下标为 (元素值 + k)/(k+1)1.遍历原始数组 arr 找到最大值和最小值，确定桶数 k2.对桶内的数做排序3.遍历所有的桶，输出结果#include #i...
STL源码分析：浅析list的sort函数
HerofH_的博客
10-07 940
目录 原理说明 举例说明 总结 虽然STL中提供了标准的sort函数，但是它只适用于随机存取的容器，而显然list并不是这样的容器，因此list提供了专用的链表排序函数，虽然同样名为sort，但是这个sort函数是list类的成员函数。 在分析list的sort函数之前，有必要先简单了解一下list其它几个相关的成员函数。 swap函数：传入参数为一个li...
浅析Java集合中的排序算法
Java技术攻略的博客
02-20 230
通过该方法注释，查看到有三项值得关注的信息，大概意思是该方法实现了稳定且默认升序排序的功能。进入sort，代码进入到List类的sort方法，发现方法将入参list先转为了数组Object[]，之后利用Arrays.sort进行排序。i.next();首先在这里思考一个问题为什么要转为数组，问题答案已经在方法的英文注释中说明白了。是为了避免直接对List的链表进行排序，从而耗费O(n2logn) 时间复杂度。
架构师技能1：工程规范、浅析领域模型VO、DTO、DO、PO、优秀命名
热门推荐
黄规速博客:学如逆水行舟，不进则退
05-23 1万+
java顶层文件结构：理解和浅析VO、DTO、DO(Entity)、PO 把我们之前项目的相关规范做了个总结记录下来，仅供参考，望能有点帮助。
C语言 算法 排序 数据结构 哈希表等
12-07
此文档，包含了 树，二叉树，数据结构与算法，排序，哈希表等难点重点详解。希望对于学习有帮助。
哈希链表c语言实现，可以直接用来做项目
08-28
不用我多说了，常用的一些基本数据结构，可以直接用于项目开发的，便于大家学习交流。
uthash表操作函数
08-07
hash表操作函数 HASH_ADD_INT HASH_ADD_STR
C开源hash代码uthash
10-09
uthash 是C的比较优秀的开源代码，它实现了常见的hash操作函数，例如查找、插入、删除等待。该套开源代码采用宏的方式实现hash函数的相关功能，支持C语言的任意数据结构最为key值，甚至可以采用多个值作为key，无论是自定义的struct还是基本数据类型，需要注意的是不同类型的key其操作接口方式略有不通。。 uthash的插入、查找、删除的操作时间都是常量，当然这个常量的值收到key以及所选择的hash函数的影响。
UT hash的学习
yu1500772557的博客
09-07 1060
UT hash的学习1. 定义2. 添加3. 查找4. 删除5. 统计6. 排序7. 例子 1. 定义 struct hash_node { int preSum; /* we'll use this field as the key */ int count; UT_hash_handle hh; /* makes this structure hashable */ }; 2. 添加 HASH_ADD_INT(haslTb, preSum, hashNd); 第一个参数：是自
hash 表 插入数据自动排序 简单实现
qq_56150055的博客
08-03 497
1,首先定义节点 一个hash表里面存了10 个链表节点 基于这个原理读者可以实现更为复杂的hash表 要想更复杂 就可以定义一个新的结构体 里面含有多个hash表指针 层层套娃 下面是一个表中10个链表节点的实现 struct MyNode { int date; MyNode* pNext; }; struct HashTable { MyNode* val[10]; // 10个链表节点 }; 2，数据存放 我们可以自己定义一个规则将数据 按照这个规则将数据存放在相应的链表...
哈希表+排序（冒泡，选择，插入，快速）
qq_43230169的博客
07-27 338
数据结构，哈希表，快速排序，插入排序
希尔排序和哈希表
csdnoyns的博客
01-05 2392
希尔排序（Shell’s method）又称为“缩小增量排序”（Diminishing Increment Sort）。 基本思想：先取一个小于n的整数d1并作为第一个增量，将文件的全部记录分成d1个组，所有距离为d1倍数的记录放在同一个组中，在各组内进行直接插入排序；然后取第二个增量d2&amp;amp;amp;amp;amp;lt;d1，重复上述的分组和排序，直至所取的增量dt=1(dt&amp;amp;amp;amp;amp;lt;…&amp;amp;amp;amp;amp;
哈希表(uthash)详解
机会是给有准备的人
07-26 3622
哈希表uthash的使用详解
链表排序新策略：冒泡排序与交换指针方法
除了冒泡排序和交换指针这两种链表排序的方法外，还有一些其他的排序算法也适用于链表： - **归并排序**：链表的归并排序利用了分治策略，将链表分成较小的链表，分别进行排序，然后合并这些有序的链表。归并排序的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值