1：SList结构

  1. typedef struct _GSList GSList;
  2. struct _GSList
  3. {
  4. gpointer data;
  5. GSList *next;
  6. };

2: SList 原型

  1. GSList* g_slist_append (GSList *list,
  2. gpointer data) G_GNUC_WARN_UNUSED_RESULT;
  3. GSList* g_slist_prepend (GSList *list,
  4. gpointer data) G_GNUC_WARN_UNUSED_RESULT;
  5. GSList* g_slist_insert (GSList *list,
  6. gpointer data,
  7. gint position) G_GNUC_WARN_UNUSED_RESULT;
  8. GSList* g_slist_insert_sorted (GSList *list,
  9. gpointer data,
  10. GCompareFunc func) G_GNUC_WARN_UNUSED_RESULT;
  11. GSList* g_slist_insert_sorted_with_data (GSList *list,
  12. gpointer data,
  13. GCompareDataFunc func,
  14. gpointer user_data) G_GNUC_WARN_UNUSED_RESULT;
  15. GSList* g_slist_insert_before (GSList *slist,
  16. GSList *sibling,
  17. gpointer data) G_GNUC_WARN_UNUSED_RESULT;
  18. GSList* g_slist_concat (GSList *list1,
  19. GSList *list2) G_GNUC_WARN_UNUSED_RESULT;
  20. GSList* g_slist_remove (GSList *list,
  21. gconstpointer data) G_GNUC_WARN_UNUSED_RESULT;
  22. GSList* g_slist_remove_all (GSList *list,
  23. gconstpointer data) G_GNUC_WARN_UNUSED_RESULT;
  24. GSList* g_slist_remove_link (GSList *list,
  25. GSList *link_) G_GNUC_WARN_UNUSED_RESULT;
  26. GSList* g_slist_delete_link (GSList *list,
  27. GSList *link_) G_GNUC_WARN_UNUSED_RESULT;
  28. GSList* g_slist_reverse (GSList *list) G_GNUC_WARN_UNUSED_RESULT;
  29. GSList* g_slist_copy (GSList *list) G_GNUC_WARN_UNUSED_RESULT;
  30. GSList* g_slist_nth (GSList *list,
  31. guint n);
  32. GSList* g_slist_find (GSList *list,
  33. gconstpointer data);
  34. GSList* g_slist_find_custom (GSList *list,
  35. gconstpointer data,
  36. GCompareFunc func);
  37. gint g_slist_position (GSList *list,
  38. GSList *llink);
  39. gint g_slist_index (GSList *list,
  40. gconstpointer data);
  41. GSList* g_slist_last (GSList *list);
  42. guint g_slist_length (GSList *list);
  43. void g_slist_foreach (GSList *list,
  44. GFunc func,
  45. gpointer user_data);
  46. GSList* g_slist_sort (GSList *list,
  47. GCompareFunc compare_func) G_GNUC_WARN_UNUSED_RESULT;
  48. GSList* g_slist_sort_with_data (GSList *list,
  49. GCompareDataFunc compare_func,
  50. gpointer user_data) G_GNUC_WARN_UNUSED_RESULT;
  51. gpointer g_slist_nth_data (GSList *list,
  52. guint n);

3：SList 实例

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <glib.h>
  5. #include <glib/gprintf.h>
  6. /*
  7. * g_slist_append
  8. * g_slist_prepend
  9. * g_slist_reverse
  10. */
  11. static void
  12. test_slist_1(void)
  13. {
  14. GSList *slist = NULL;
  15. GSList *st;
  16. gint nums[10] = {0,1,2,3,4,5,6,7,8,9};
  17. gint i;
  18. for (i = 0; i < 10; i++)
  19. // GSList* g_slist_append(GSList *list, gpointer data);
  20. slist = g_slist_append(slist, &nums[i]);
  21. g_printf("The result should be: 0,1,2,3,4,5,6,7,8,9\n");
  22. g_printf("Begin:\n");
  23. for (i = 0; i < 10; i++) {
  24. st = g_slist_nth(slist, i);
  25. g_printf("%d,", *(gint*)st->data);
  26. }
  27. g_printf("\nDone\n");
  28. // GSList* g_slist_reverse(GSList *list);
  29. slist = g_slist_reverse(slist);
  30. g_printf("The result should be: 9,8,7,6,5,4,3,2,1,0\n");
  31. g_printf("Begin:\n");
  32. for (i = 0; i < 10; i++) {
  33. st = g_slist_nth(slist, i);
  34. g_printf("%d,", *(gint*)st->data);
  35. }
  36. g_printf("\nDone\n");
  37. for (i = 0; i < 10; i++)
  38. // GSList* g_slist_prepend(GSList *list, gpointer data);
  39. slist = g_slist_prepend(slist, &nums[i]);
  40. g_printf("The result should be: 9,8,7,6,5,4,3,2,1,0,9,8,7,6,5,4,3,2,1,0\n");
  41. g_printf("Begin:\n");
  42. for (i = 0; i < 20; i++) {
  43. st = g_slist_nth(slist, i);
  44. g_printf("%d,", *(gint*)st->data);
  45. }
  46. g_printf("\nDone\n");
  47. g_slist_free(slist);
  48. }
  49. /*
  50. * g_slist_insert_before
  51. * g_slist_insert
  52. * g_slist_nth
  53. * g_slist_copy
  54. */
  55. static void
  56. test_slist_2(void)
  57. {
  58. GSList *slist = NULL;
  59. GSList *st;
  60. GSList *st2;
  61. gint nums[10] = {0,1,2,3,4,5,6,7,8,9};
  62. gint i;
  63. // GSList* g_slist_insert_before(GSList *slist, GSList *sibling, gpointer data);
  64. slist = g_slist_insert_before(NULL, NULL, &nums[1]);
  65. // GSList* g_slist_insert(GSList *list, gpointer data, gint position);
  66. slist = g_slist_insert(slist, &nums[3], 1);
  67. slist = g_slist_insert(slist, &nums[4], -1);
  68. slist = g_slist_insert(slist, &nums[0], 0);
  69. slist = g_slist_insert(slist, &nums[5], 100);
  70. slist = g_slist_insert_before(slist, NULL, &nums[6]);
  71. slist = g_slist_insert_before(slist, slist->next->next, &nums[2]);
  72. slist = g_slist_insert(slist, &nums[9], 7);
  73. slist = g_slist_insert(slist, &nums[8], 7);
  74. slist = g_slist_insert(slist, &nums[7], 7);
  75. g_printf("The result should be: 0,1,2,3,4,5,6,7,8,9\n");
  76. g_printf("Begin:\n");
  77. for (i = 0; i < 10; i++) {
  78. // GSList* g_slist_nth(GSList *list, guint n);
  79. st = g_slist_nth(slist, i);
  80. g_printf("%d,", *(gint*)st->data);
  81. }
  82. g_printf("\nDone\n");
  83. // GSList* g_slist_copy(GSList *list);
  84. st = g_slist_copy(slist);
  85. g_printf("The result should be: 0,1,2,3,4,5,6,7,8,9\n");
  86. g_printf("Begin:\n");
  87. for (i = 0; i < 10; i++) {
  88. st2 = g_slist_nth(st, i);
  89. g_printf("%d,", *(gint*)st2->data);
  90. }
  91. g_printf("\nDone\n");
  92. g_slist_free(st);
  93. g_slist_free(slist);
  94. }
  95. /*
  96. * g_slist_lenth
  97. * g_slist_remove
  98. * g_slist_remove_all
  99. * g_slist_last
  100. * g_slist_next
  101. */
  102. static void
  103. test_slist_3(void)
  104. {
  105. GSList *slist = NULL;
  106. GSList *st;
  107. gint nums[10] = {0,1,2,3,4,5,6,7,8,9};
  108. gint i;
  109. for (i = 0; i < 10; i++) {
  110. slist = g_slist_append(slist, &nums[i]);
  111. slist = g_slist_append(slist, &nums[i]);
  112. }
  113. // guint g_slist_lenth(GSList *list);
  114. g_printf("The length should be 20.\nResult:%d\n", g_slist_length(slist));
  115. for (i = 0; i < 10; i++)
  116. // GSList* g_slist_remove_all(GSList *list, gconstpointer data);
  117. slist = g_slist_remove_all(slist, &nums[i]);
  118. g_printf("The length should be 0.\nResult:%d\n", g_slist_length(slist));
  119. for (i = 0; i < 10; i++) {
  120. slist = g_slist_append(slist, &nums[i]);
  121. slist = g_slist_append(slist, &nums[i]);
  122. }
  123. for (i = 0; i < 10; i++)
  124. // GSList* g_slist_remove(GSList *list, gconstpointer data);
  125. slist = g_slist_remove(slist, &nums[i]);
  126. g_printf("The length should be 10.\nResult:%d\n", g_slist_length(slist));
  127. g_printf("The first should be 0.\nResult:%d\n", *(gint*)slist->data);
  128. // GSList* g_slist_last(GSList *list);
  129. g_printf("The last should be 9.\nResult:%d\n", *(gint*)g_slist_last(slist)->data);
  130. g_printf("The first:");
  131. g_printf("%d\n", *(gint*)slist->data);
  132. st = slist;
  133. for (i = 0; i < 9; i++) {
  134. // #define g_slist_next (slist)
  135. st = g_slist_next(st);
  136. g_printf("The next:%d\n", *(gint*)st->data);
  137. }
  138. g_slist_free(slist);
  139. }
  140. static gint
  141. find_num(gconstpointer l, gconstpointer data)
  142. {
  143. return *(gint*)l - GPOINTER_TO_INT(data);
  144. }
  145. /*
  146. * g_slist_index
  147. * g_slist_position
  148. * g_slist_find_custom
  149. */
  150. static void
  151. test_slist_4(void)
  152. {
  153. GSList *slist = NULL;
  154. GSList *st;
  155. gint nums[10] = {0,1,2,3,4,5,6,7,8,9};
  156. gint i;
  157. for (i = 0; i < 10; i++) {
  158. slist = g_slist_append(slist, &nums[i]);
  159. }
  160. // gint g_slist_index(GSList *list, gconstpointer data);
  161. g_printf("The index should be -1.\nResult:%d\n", g_slist_index(slist, NULL));
  162. // gint g_slist_position(GSList *list, GSList *llink);
  163. g_printf("The position should be -1.\nResult:%d\n", g_slist_position(slist, NULL));
  164. for (i = 0; i < 10; i++) {
  165. // GSList* g_slist_find_custom(GSList *list, gconstpointer data, GCompareFunc func);
  166. st = g_slist_find_custom(slist, GINT_TO_POINTER(i), find_num);
  167. g_printf("The position should be %d.\nResult:%d\n", i, g_slist_position(slist, st));
  168. }
  169. g_slist_free(slist);
  170. }
  171. #define SIZE        10
  172. #define NUMBER_MAX    99
  173. static guint32 array[SIZE];
  174. static gint
  175. sort(gconstpointer p1, gconstpointer p2)
  176. {
  177. gint32 a, b;
  178. a = GPOINTER_TO_INT (p1);
  179. b = GPOINTER_TO_INT (p2);
  180. return (a > b ? +1 : a == b ? 0 : -1);
  181. }
  182. static gint
  183. sort_r(gconstpointer p1, gconstpointer p2)
  184. {
  185. gint32 a, b;
  186. a = GPOINTER_TO_INT (p1);
  187. b = GPOINTER_TO_INT (p2);
  188. return (a < b ? +1 : a == b ? 0 : -1);
  189. }
  190. /*
  191. * g_slist_sort
  192. * g_slist_sort_with_data
  193. * g_slist_nth_data
  194. */
  195. static void
  196. test_slist_5(void)
  197. {
  198. GSList *slist = NULL;
  199. gint i;
  200. for (i = 0; i < SIZE; i++)
  201. slist = g_slist_append(slist, GINT_TO_POINTER(array[i]));
  202. // GSList* g_slist_sort(GSList *list, GCompareFunc compare);
  203. slist = g_slist_sort(slist, sort);
  204. g_printf("The result should be sorted.\nResult:");
  205. for (i = 0; i < SIZE; i++) {
  206. // gpointer g_slist_nth_data(GSList *list, guint n);
  207. gpointer p = g_slist_nth_data(slist, i);
  208. g_printf("%d,", GPOINTER_TO_INT(p));
  209. }
  210. g_printf("\n");
  211. // GSList* g_slist_sort_with_data(GSList *list, GCompareDataFunc compare_func, gpinter user_data);
  212. slist = g_slist_sort_with_data(slist, (GCompareDataFunc)sort_r, NULL);
  213. g_printf("The result should be sorted[reversed].\nResult:");
  214. for (i = 0; i < SIZE; i++) {
  215. gpointer p = g_slist_nth_data(slist, i);
  216. g_printf("%d,", GPOINTER_TO_INT(p));
  217. }
  218. g_printf("\n");
  219. g_slist_free(slist);
  220. }
  221. static void
  222. print(gpointer p1, gpointer p2)
  223. {
  224. g_printf("%d,", GPOINTER_TO_INT(p1));
  225. }
  226. /*
  227. * g_slist_insert_sorted
  228. * g_slist_insert_sorted_with_data
  229. * g_slist_concat
  230. * g_slist_foreach
  231. */
  232. static void
  233. test_slist_6(void)
  234. {
  235. GSList *slist = NULL;
  236. GSList *st = NULL;
  237. GSList *sc = NULL;
  238. gint i;
  239. for (i = 0; i < SIZE; i++) {
  240. // GSList* g_slist_insert_sorted(GSList *list, gpointer data, GCompareFunc func);
  241. slist = g_slist_insert_sorted(slist, GINT_TO_POINTER(array[i]), sort);
  242. // GSList* g_slist_insert_sorted_with_data(GSList *list, gpointer data,
  243. //                            GCompareDataFunc func,
  244. //                            gpinter user_data);
  245. st = g_slist_insert_sorted_with_data(st, GINT_TO_POINTER(array[i]),
  246. (GCompareDataFunc)sort_r,
  247. NULL);
  248. }
  249. g_printf("The result should be sorted.\nResult:");
  250. for (i = 0; i < SIZE; i++) {
  251. gpointer p = g_slist_nth_data(slist, i);
  252. g_printf("%d,", GPOINTER_TO_INT(p));
  253. }
  254. g_printf("\n");
  255. g_printf("The result should be sorted[reversed].\nResult:");
  256. for (i = 0; i < SIZE; i++) {
  257. gpointer p = g_slist_nth_data(st, i);
  258. g_printf("%d,", GPOINTER_TO_INT(p));
  259. }
  260. g_printf("\n");
  261. // GSList* g_slist_concat(GSList *list1, *list2);
  262. sc = g_slist_concat(slist, st);
  263. g_printf("The result should be concated.\nResult:");
  264. // void g_slist_foreach(GSList *list, GFunc func, gpointer user_data);
  265. g_slist_foreach(sc, (GFunc)print, NULL);
  266. g_printf("\n");
  267. g_slist_free(slist);
  268. g_slist_free(st);
  269. }
  270. int
  271. main(void)
  272. {
  273. printf("BEGIN:\n************************************************************\n");
  274. printf("\n------------------------------------------------------------\ntest_slist_1:\n");
  275. printf("------------------------------------------------------------\n");
  276. test_slist_1();
  277. printf("\n------------------------------------------------------------\ntest_slist_2:\n");
  278. printf("------------------------------------------------------------\n");
  279. test_slist_2();
  280. printf("\n------------------------------------------------------------\ntest_slist_3:\n");
  281. printf("------------------------------------------------------------\n");
  282. test_slist_3();
  283. printf("\n------------------------------------------------------------\ntest_slist_4:\n");
  284. printf("------------------------------------------------------------\n");
  285. test_slist_4();
  286. int i;
  287. srand((unsigned)time(0));
  288. printf("The init array is:\n");
  289. for (i = 0; i < SIZE; i++) {
  290. array[i] = rand() % (NUMBER_MAX+1);
  291. printf("%d,", array[i]);
  292. }
  293. printf("\n");
  294. printf("\n------------------------------------------------------------\ntest_slist_5:\n");
  295. printf("------------------------------------------------------------\n");
  296. test_slist_5();
  297. printf("\n------------------------------------------------------------\ntest_slist_6:\n");
  298. printf("------------------------------------------------------------\n");
  299. test_slist_6();
  300. printf("\n************************************************************\nDONE\n");
  301. return 0;
  302. }

转载自：http://blog.chinaunix.net/space.php?uid=25696269&do=blog&id=483448

转载于:https://blog.51cto.com/yifangyou/610321

Glib实例学习（1）单链表相关推荐

  1. Go 学习笔记（80）— Go 标准库 container/list（单链表、双链表）

    列表是一种非连续存储的容器,由多个节点组成,节点通过一些变量记录彼此之间的关系.列表有多种实现方法,如单链表.双链表等. ​ 在 Go 语言中,将列表使用 container/list 包来实现,内部 ...

  2. 数据结构（08）— 线性单链表基本操作

    1. 线性单链表数据结构 // 假定每个结点的类型用 SNode 表示 typedef struct SNodeTag {int data; // 所存储的数据元素SNodeTag *next; // ...

  3. 数据结构（05）— 线性单链表实战

    1. 设计思路 本项目的实质是完成对考生信息的建立.查找.插入.修改.删除等功能,可以首先定义项目的数据结构,然后将每个功能写成一个函数来完成对数据的操作,最后完成主函数以验证各个函数功能并得出运行结 ...

  4. 带头节点单链表的增删改查

    单链表有很多结构循环单链表,有头节点的单链表,无头节点的单链表,双节点单链表,以下源码是以有一个头节点的单链表为例写的增删改查的各种功能,就是下图 然后各个注释也在函数后面写着,这玩意确实还挺难,源码 ...

  5. 数据结构--单链表（数组）

    文章目录 单链表 单链表 用数组实现的单链表可以在任意位置插入.删除.替换一个数,相比于用结构体和指针实现的动态链表而言,数组模拟链表运行的速度非常快,动态链表基本会出现超时的现象.但缺点是浪费内存 ...

  6. 数据结构和算法：（3）3.2.2单链表的整表删除

    我们不使用这个单链表时,我们需要把他在内存中释放掉,以便于流出空间给其他程序和软件使用. 单链表整表删除的算法思路如下: 声明结点p和q: 将第一个结点赋值给p,下一个结点(也就是第一个结点的下一个结 ...

  7. 数据结构和算法：（3）3.2.1单链表的整表创建

    对于顺序存储结构的线性表的整表创建,我们可以用数组的初始化来直观理解.(因为之前说过我们线性表的顺序存储结构呢事实上也就是在数组的基础上加多一个变量来存储当前线性表的长度构成的一个结构,所以我们用数组 ...

  8. 数据结构与算法（2-2）线性表之链式存储（单链表、静态链表、循环链表、双向循环链表）

    目录 一.单链表 1.存储方式 2.插入 3.删除 总代码: 二.静态链表 1.存储方式 2.插入 3.删除 4.遍历 总代码: 三.循环链表 总代码: 四.双向循环链表 1.存储方式: 2.插入和删 ...

  9. 删除单链表中的重复节点(c语言版本)

    这是一道经典的面试题,下面是我的研究和举一反三,特整理如下: 分为三种情形: (1)删除有序链表的重复节点,重复节点一个都不留 (2)删除有序链表的重复节点,重复节点只留一个 (3)删除无序链表的重复 ...

  10. C语言的单链表求交点

    单链表求交点,问题如下: 使用o(1)的空间复杂度,求两个链表相交的时候的交点,这个思想就类似于使用o(1)的空间复杂度和o(n)的时间复杂度来求链表的第k个节点. 过程如下: 获取两个链表的长度 将 ...

最新文章

  1. java 前端基础知识_【计算机·知识】关于前端的计算机基础知识
  2. 海量数据处理：从并发编程到分布式系统
  3. C++运算符重载形式--成员函数or友元函数?
  4. java中的localDate类_java8-LocalDate类
  5. 主从复制1062错误的解决方法
  6. 本文将引导你使用XNA Game Studio Express一步一步地创建一个简单的游戏
  7. python zipfile模块 ZIP64
  8. 企业实战03：Oracle数据库_用户和表空间
  9. c++里面的内联函数
  10. [Ext JS]Grid的列过滤
  11. Android数据库hibernate框架
  12. 全新的移动界面设计素材
  13. IOS UIScrollView中 使用 touch 无法响应的问题
  14. 函数r语言_[R learning]-0006-R语言的基本函数
  15. linux sleeping进程多_你知道Linux进程的睡眠和唤醒操作？
  16. 拼音模糊查询+java,拼音模糊查询实现
  17. FreeCAD源码分析：Path模块
  18. mcu AD采样值和物理值
  19. linux查显卡型号_Windows/Linux下怎么查看笔记本显卡型号
  20. 【UnblockNeteaseMusic】代理网易云后隐藏NODE代理窗口方法

热门文章

  1. 机器学习第二回——矩阵部分总结
  2. 二维数组，字符串，字符数组
  3. 【ArcGIS操作】3 数据制图篇
  4. Fiddler自动保存抓包内容到文件
  5. 物理机安装linux系统,物理机安装linux的三种方法
  6. Flutter学习资源汇总（不定期更新）
  7. Android okhttp https TrustManager简单总结
  8. Flutter之CupertinoSwitch和Switch开关组件的简单使用
  9. Flink+Hudi 构架湖仓一体化解决方案
  10. 互联网职场红利真的不多了~