Chinaunix首页 | 论坛 | 博客

SIMPLESlego.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

HuangLei_LEGO

  • 博客访问： 2618378
  • 博文数量： 315
  • 博客积分： 3901
  • 博客等级： 少校
  • 技术积分： 3640
  • 用 户 组： 普通用户
  • 注册时间： 2011-05-08 15:32
个人简介

知乎：https://www.zhihu.com/people/monkey.d.luffy Android高级开发交流群2: 752871516

文章分类

全部博文（315）

文章存档

2019年（2）

2018年（1）

2016年（7）

2015年（32）

2014年（39）

2013年（109）

2012年（81）

2011年（44）

我的朋友
最近访客
推荐博文
相关博文
二级链表

分类： C/C++

2012-10-09 20:53:13

    快乐学习，快乐生活！

点击(此处)折叠或打开

  1. /**
  2.  * 通用平台逻辑模块组
  3.  * Copyright (c) 2012 xxxx
  4.  *
  5.  * @file linkers.c
  6.  * @brief 二级链表
  7.  * @author
  8.  * @date 2012/10/9
  9.  *
  10.  */
  11.  
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>

  16. /**
  17.  * @brief 二级链表
  18.  */
  19. typedef struct _Menu Menu;
  20. typedef struct _ChildMenu ChildMenu;

  22. /// < 第二级链表
  23. struct _ChildMenu
  24. {
  25.     char * m_name;
  26.     ChildMenu * cNext;
  27. };

  29. /// < 第一级链表
  30. struct _Menu
  31. {
  32.     char * m_name;
  33.     Menu * pMenu;

  35.     int count;
  36.     ChildMenu * pChildMenu;
  37. };

  39. /// < 初始化链表
  40. Menu * initMenu()
  41. {
  42.     Menu * pHead = NULL;
  43.     Menu * pNext = NULL;
  44.     ChildMenu * pcHead = NULL;

  46.     int i , j;

  48.     for (i = 0; i < 2; i)
  49.     {
  50.         Menu * pMenu = (Menu *)malloc(sizeof(Menu));
  51.         if (!pMenu)
  52.             return NULL;
  53.         memset(pMenu, 0, sizeof(Menu));

  55.         pMenu->m_name = (char *)malloc(3);
  56.         if (!pMenu->m_name)
  57.             return NULL;
  58.         memset(pMenu->m_name, 0, 3);
  59.         strcpy(pMenu->m_name, "a");

  61.         pMenu->count = 2;

  63.         if (0 == i)
  64.         {
  65.             pHead = pNext = pMenu;
  66.             pMenu->pMenu = NULL;
  67.         }
  68.         else
  69.         {
  70.             pNext->pMenu = pMenu;
  71.             pMenu->pMenu = NULL;
  72.             pNext = pMenu;
  73.         }

  75.         for (j = 0; j < pMenu->count; j)
  76.         {
  77.             ChildMenu * pChildMenu = (ChildMenu *)malloc(sizeof(ChildMenu));
  78.             if (!pChildMenu)
  79.                 return NULL;
  80.             pChildMenu->m_name = (char *)malloc(3);
  81.             if (!pChildMenu->m_name)
  82.                 return NULL;
  83.             memset(pChildMenu->m_name, 0, 3);
  84.             strcpy(pChildMenu->m_name, "b");

  86.             if (0 == j)
  87.             {
  88.                 pNext->pChildMenu = pChildMenu;
  89.                 pcHead = pChildMenu;
  90.                 pChildMenu->cNext = NULL;
  91.             }
  92.             else
  93.             {
  94.                 pcHead->cNext = pChildMenu;
  95.                 pChildMenu->cNext = NULL;
  96.                 pcHead = pChildMenu;
  97.             }
  98.         }
  99.     }

  101.     return pHead;
  102. }

  104. /// < 二级链表的遍历
  105. void traverse_linker(const Menu * head)
  106. {
  107.     const Menu * p = head;
  108.     ChildMenu * q;
  109.     int i;

  111.     if (!head)
  112.         return ;

  114.     while (p)
  115.     {
  116.         printf("-%s\n", p->m_name);
  117.         q = p->pChildMenu;
  118.         for (i = 0; i < p->count; i) /// < 有个数就是好！
  119.         {
  120.             printf(" --%s", q->m_name);
  121.             q = q->cNext;
  122.         }
  123.         putchar('\n');

  125.         p = p->pMenu;
  126.     }
  127. }

  129. /// < 二级链表的释放 - 从头开始
  130. void free_linker(Menu ** head)
  131. {
  132.     Menu * firstgo = NULL; /// < 负责一级链表
  133.     ChildMenu * childgo = NULL; /// < 负责二级链表
  134.     Menu * firstNext = NULL; /// < 指向一级链表的后一个
  135.     ChildMenu * childNext = NULL; /// < 指向二级链表后一个
  136.     if (!(*head))
  137.         return;
  138.     firstgo = *head;
  139.     while (firstgo)
  140.     {
  141.         firstNext = firstgo->pMenu;
  142.         childgo = firstgo->pChildMenu;
  143.         while (childgo)
  144.         {
  145.             /// < 释放第二级链表
  146.             childNext = childgo->cNext;
  147.             
  148.             free(childgo->m_name);
  149.             free(childgo);
  150.             /// < 下一个
  151.             childgo = childNext;
  152.         }
  153.         
  154.         /// < 释放第一级链表
  155.         free(firstgo->m_name);
  156.         free(firstgo);
  157.         /// < 下一个
  158.         firstgo = firstNext;
  159.     }
  160.     *head = NULL;
  161. }

  163. /**
  164.  * @brief 鉴于所使用的环境，carbide.c ；所以用gcc调试，用symbian os application进行内存泄漏检查！
  165.  * 突然发现symbian模拟器运行程序挺爽的，关闭后检查你的内存泄漏。挺好，应该还有很多工具可以检查，目前
  166.  * 这个不错！不过调试的话，看内存，看变量就可以了，不需要去打印哈！你懂的..
  167.  */
  168. int main()
  169. {
  170.     Menu * pMenu = initMenu();

  172.     /* printf("%s ", pMenu->m_name);
  173.        printf("%d\n", pMenu->count);
  174.        printf(" -->%s -->", pMenu->pChildMenu->m_name);
  175.        printf("%s\n", pMenu->pChildMenu->cNext->m_name);

  177.        printf("%s ", pMenu->pMenu->m_name);
  178.        printf("%d\n", pMenu->pMenu->count);
  179.        printf(" -->%s -->", pMenu->pMenu->pChildMenu->m_name);
  180.        printf("%s\n", pMenu->pMenu->pChildMenu->cNext->m_name);
  181.        */
  182.     traverse_linker(pMenu);
  183.     free_linker(&pMenu);
  184.     /// < 证明下
  185.     traverse_linker(pMenu);
  186.     return 0;
  187. }

点击(此处)折叠或打开

  1. /**
  2.  * 通用平台逻辑模块组
  3.  * Copyright (c) 2012 xxxx
  4.  *
  5.  * @file linkers2.c
  6.  * @brief 二级链表2
  7.  * @author
  8.  * @date 2012/10/9
  9.  *
  10.  */

  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>

  16. /**
  17.  * @brief 二级链表2
  18.  */
  19. typedef struct _Menu Menu;
  20. struct _Menu
  21. {
  22.     int id;
  23.     char * name;

  25.     Menu * brother; /// < 兄弟节点 - 作为一级链表
  26.     Menu * child; /// < 儿子节点 - 作为二级或者多级链表（针对节点结构都相同）
  27. };

  29. /**
  30.  * @brief 初始化
  31.  * 类似：
  32.  * -文件 --打开
  33.  * --保存
  34.  * --退出
  35.  *
  36.  * -1 --11
  37.  * --11
  38.  * --11
  39.  * -1 --11
  40.  * --11
  41.  * --11
  42.  */
  43. Menu * initial_link()
  44. {
  45.     Menu * head;
  46.     Menu * next;

  48.     Menu * cnext;

  50.     int i, j;
  51.     for (i = 0; i < 3; i) /// < 三兄弟
  52.     {
  53.         Menu * pTemp = (Menu *)malloc(sizeof(Menu));
  54.         if (!pTemp)
  55.             return NULL;
  56.         memset(pTemp, 0, sizeof(Menu));

  58.         pTemp->name = (char *)malloc(2);
  59.         if (!pTemp->name)
  60.             return NULL;
  61.         strcpy(pTemp->name, "1");
  62.         pTemp->id = 1;

  64.         if (0 == i)
  65.         {
  66.             head = next = pTemp;
  67.             pTemp->brother = NULL;
  68.             pTemp->child = NULL;
  69.         }
  70.         else
  71.         {
  72.             next->brother = pTemp;
  73.             pTemp->brother = NULL;
  74.             pTemp->child = NULL;
  75.             next = pTemp;
  76.         }

  78.         for (j = 0; j < 3; j) /// < 一个儿子，两个孙子
  79.         {
  80.             Menu * pTempc = (Menu *)malloc(sizeof(Menu));
  81.             if (!pTempc)
  82.                 return NULL;
  83.             memset(pTempc, 0, sizeof(Menu));

  85.             pTempc->name = (char *)malloc(3);
  86.             if (!pTempc->name)
  87.                 return NULL;
  88.             strcpy(pTempc->name, "11");
  89.             pTempc->id = 11;

  91.             if (0 == j)
  92.             {
  93.                 next->child = pTempc;
  94.                 cnext = pTempc;
  95.                 pTempc->brother = NULL;
  96.                 pTempc->child = NULL;
  97.             }
  98.             else
  99.             {
  100.                 cnext->child = pTempc;
  101.                 pTempc->brother = NULL;
  102.                 pTempc->child = NULL;
  103.                 cnext = pTempc;
  104.             }
  105.         }
  106.     }

  108.     return head;
  109. }

  111. /**
  112.  * @brief 遍历
  113.  */
  114. void traverse_linker(const Menu * head)
  115. {
  116.     const Menu * p = head;
  117.     const Menu * q;
  118.     if (!head)
  119.         return ;

  121.     while (p)
  122.     {
  123.         printf("-%d %s\n", p->id, p->name);
  124.         q = p->child;
  125.         while (q)
  126.         {
  127.             printf(" --%d %s\n", q->id, q->name);
  128.             q = q->child;
  129.         }
  130.         p = p->brother;
  131.     }
  132. }

  134. /*
  135.  * @brief 二级链表的释放 - 从头开始 和linker一样的方式。不过仔细一看这种方式有问题？儿子还有儿子没考虑！不过从经验来看，我们开发手机软件
  136.  * 所需要的菜单不会非常多，因此我们不必去绞尽脑汁像一个通用遍历的方法，没有必要！你认为了...
  137.  */
  138. void free_linker(Menu ** head)
  139. {
  140.     Menu * firstgo = NULL; /// < 负责一级链表
  141.     Menu * childgo = NULL; /// < 负责二级链表
  142.     Menu * firstNext = NULL; /// < 指向一级链表的后一个
  143.     Menu * childNext = NULL; /// < 指向二级链表后一个
  144.     if (!(*head))
  145.         return;
  146.     firstgo = *head;
  147.     while (firstgo)
  148.     {
  149.         firstNext = firstgo->brother;
  150.         childgo = firstgo->child;
  151.         while (childgo)
  152.         {
  153.             /// < 释放第二级链表
  154.             childNext = childgo->child;

  156.             free(childgo->name);
  157.             free(childgo);
  158.             /// < 下一个
  159.             childgo = childNext;
  160.         }

  162.         /// < 释放第一级链表
  163.         free(firstgo->name);
  164.         free(firstgo);
  165.         /// < 下一个
  166.         firstgo = firstNext;
  167.     }
  168.     *head = NULL;
  169. }


  172. int main(int argc, char **argv)
  173. {
  174.     Menu * head = initial_link();
  175.     traverse_linker(head);
  176.     free_linker(&head);

  178.     return 0;
  179. }
接着哦！

点击(此处)折叠或打开

  1. /*
  2.  ============================================================================
  3.  Name : linkerList3.c
  4.  Author : hl
  5.  Version :
  6.  Copyright : Copyright (c) 2012 Tiros
  7.  Description : Linker3 in C, Ansi-style
  8.  ============================================================================
  9.  */

  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <string.h>

  15. /**
  16.  * @brief 可扩展性的二级链表 （参考Company）
  17.  */
  18. typedef struct _linkerList linkerList;

  20. /**
  21.  * @brief “真实”数据
  22.  */
  23. typedef struct _Data
  24. {
  25.     int id;
  26.     char * name;
  27. }Data;

  29. /// < 链表结点 - 描述结点的子结点个数和数据信息
  30. typedef struct _linkerNodeData
  31. {
  32.     Data * pData; /// < 数据
  33.     int childNodesCount; /// < 子链表的个数
  34.     linkerList * plinkerList;
  35. }linkerNodeData;

  37. /// < 二级链表 - 之所以这样封装的原因：如果取消该包装，那么我们要实现二级链表就只能像之前，在linkerNodeData中定义一个brother指针来指向下一个条目，画画图就知道了；我们再linkerNodeData中"回调"linkerList就相当于包含了一个数据类型和指向下一个结点的指针的集合！
  38. struct _linkerList
  39. {
  40.    linkerNodeData * pNodeData;
  41.    linkerList * pNext;
  42. };

  44. static Data * createData(int id, char * name);
  45. static linkerList * cratelinkerList(int id, char * name, int count);
  46. static linkerNodeData * createlinkerNodeData(int id, char * name, int count);

  48. /**
  49.  * @brief "定值"初始化 问题很严重，代码冗余，逻辑混乱
  50.  */
  51. /*linkerList * initLinker()
  52. {
  53.    linkerList * pHead;
  54.    linkerList * pNext;
  55.    int i = 0;
  56.    int j = 0;

  58.    for ( ; i < 3; ++i) /// < 三个一级菜单条目
  59.    {
  60.        linkerList * pTmp = (linkerList *)malloc(sizeof(linkerList));
  61.        if (!pTmp)
  62.            return NULL;
  63.        pTmp->pNodeData = (linkerNodeData *)malloc(sizeof(linkerNodeData));
  64.        if (!pTmp->pNodeData)
  65.        {
  66.          free(pTmp);
  67.          return NULL;
  68.        }
  69.        pTmp->pNodeData->pData = (Data *)malloc(sizeof(Data));
  70.        if (!pTmp->pNodeData->pData)
  71.        {
  72.          free(pTmp);
  73.          free(pTmp->pNodeData);
  74.          return NULL;
  75.        }
  76.        pTmp->pNodeData->pData->id = i;
  77.        pTmp->pNodeData->pData->name = (char *)malloc(10);
  78.        if (!pTmp->pNodeData->pData->name)
  79.        {
  80.          free(pTmp);
  81.             free(pTmp->pNodeData);
  82.             free(pTmp->pNodeData->pData);
  83.             return NULL;
  84.        }
  85.        memset( pTmp->pNodeData->pData->name, 0, 10);
  86.        strcpy(pTmp->pNodeData->pData->name, "文件");

  88.        if (0 == i)
  89.        {
  90.          pHead = pNext = pTmp;    ///-------
  91.          pTmp->pNext = NULL;
  92.        }
  93.        else
  94.        {
  95.          pNext->pNext = pTmp;
  96.          pTmp->pNext = NULL;
  97.          pNext = pTmp;

  99.        }

  101.        pTmp->pNodeData->childNodesCount = 1;    /// < 一个二级菜单条目

  103.        for ( j = 0; j < pTmp->pNodeData->childNodesCount; ++j)
  104.        {
  105.             linkerList * ppTmp = (linkerList *) malloc(sizeof(linkerList));
  106.             if (!ppTmp)
  107.                 return NULL;
  108.             ppTmp->pNodeData = (linkerNodeData *) malloc(sizeof(linkerNodeData));
  109.             if (!ppTmp->pNodeData)
  110.             {
  111.                 free(ppTmp);
  112.                 return NULL;
  113.             }
  114.             ppTmp->pNodeData->pData = (Data *) malloc(sizeof(Data));
  115.             if (!ppTmp->pNodeData->pData)
  116.             {
  117.                 free(ppTmp);
  118.                 free(ppTmp->pNodeData);
  119.                 return NULL;
  120.             }
  121.             ppTmp->pNodeData->pData->id = j;
  122.             ppTmp->pNodeData->pData->name = (char *) malloc(10);
  123.             if (!ppTmp->pNodeData->pData->name)
  124.             {
  125.                 free(ppTmp);
  126.                 free(ppTmp->pNodeData);
  127.                 free(ppTmp->pNodeData->pData);
  128.                 return NULL;
  129.             }
  130.             memset(ppTmp->pNodeData->pData->name, 0, 10);
  131.             strcpy(ppTmp->pNodeData->pData->name, "打开");

  133.             ppTmp->pNodeData->childNodesCount = 0;
  134.             ppTmp->pNodeData->plinkerList = NULL;    /// < 无三级了

  136.             pNext->pNext = ppTmp;
  137.             ppTmp->pNext = NULL;
  138.         }
  139.    }
  140.    return pHead;
  141. }*/

  143. /**
  144.  * @brief 释放
  145.  */
  146. void freeListNode(linkerList * head)
  147. {
  148.     if (!head)
  149.         return ;
  150. }

  152. /**
  153.  * @brief 数据创建
  154.  */
  155. Data * createData(int id, char * name)
  156. {
  157.     Data * pData = (Data *)malloc(sizeof(Data));
  158.     if (!pData)
  159.         return NULL;
  160.     /// < 项id
  161.     pData->id = id;
  162.     /// < 项名称
  163.     pData->name = (char *)malloc(strlen(name) + 1);
  164.     if (!pData->name)
  165.     {
  166.         free(pData);
  167.         return NULL;
  168.     }
  169.     memset(pData->name, 0, strlen(name) + 1);
  170.     strcpy(pData->name, name);

  172.     return pData;
  173. }

  175. /**
  176.  * @brief 链表结点创建
  177.  */
  178. linkerNodeData * createlinkerNodeData(int id, char * name, int count)
  179. {
  180.     linkerNodeData * plinkerNodeData = (linkerNodeData *)malloc(sizeof(linkerNodeData));
  181.     int i = 0;
  182.     if (!plinkerNodeData)
  183.         return NULL;
  184.     memset(plinkerNodeData, 0, sizeof(linkerNodeData));
  185.     plinkerNodeData->pData = createData(id, name);
  186.     plinkerNodeData->childNodesCount = count;

  188.     linkerList * next;
  189.     for (i = 0; i < count; ++i)
  190.     {
  191.         linkerList * plinkerList = cratelinkerList(i, name, --count);    ///特别注意
  192.         if (!plinkerList)
  193.             return NULL;
  194.         if (!plinkerNodeData->plinkerList)
  195.         {
  196.             plinkerNodeData->plinkerList = plinkerList;
  197.             next = plinkerList;
  198.             plinkerList->pNext = NULL;
  199.         }
  200.         else
  201.         {
  202.             next->pNext = plinkerList;
  203.             next = plinkerList;
  204.             plinkerList->pNext = NULL;
  205.         }
  206.     }
  207.     return plinkerNodeData;
  208. }

  210. /**
  211.  * @brief 链表创建
  212.  */
  213. linkerList * cratelinkerList(int id, char * name, int count)
  214. {
  215.     linkerList * plinkerList = NULL;    /// < 链表头指针

  217.     plinkerList = (linkerList *) malloc(sizeof(linkerList));
  218.     if (!plinkerList)
  219.         return NULL;
  220.     memset(plinkerList, 0, sizeof(linkerList));
  221.     plinkerList->pNodeData = createlinkerNodeData(id, name, count);

  223.     if (!plinkerList->pNodeData)
  224.         return NULL;

  226.     return plinkerList;
  227. }


  230. /**
  231.  * @brief "定值"初始化
  232.  */
  233. linkerList * initLinker()
  234. {
  235.     linkerList * head = NULL;
  236.     linkerList * next = NULL;
  237.     int i = 0;

  239.     head = (linkerList *) malloc(sizeof(linkerList));
  240.     if (!head)
  241.         return NULL;
  242.     memset(head, 0, sizeof(linkerList));

  244.     for ( ; i < 3; ++i)    /// < 3个一级链表
  245.     {
  246.         linkerList * pTmp = cratelinkerList(i, "文件", 2); /// < 每个一级含2个二级的
  247.         if (0 == i)
  248.         {
  249.             next = head = pTmp;
  250.             pTmp->pNext = NULL;
  251.         }
  252.         else
  253.         {
  254.             next->pNext = pTmp;
  255.             next = pTmp;
  256.             pTmp->pNext = NULL;
  257.         }
  258.     }
  259.     return head;
  260. }

  262. /**
  263.  * @brief 遍历二级链表
  264.  */
  265. void traverseLinker(linkerList * head)
  266. {
  267.     //TODO
  268. }

  270. /**
  271.  * @brief 释放
  272.  */
  273. void releaseLinker(linkerList * head)
  274. {
  275.     //TODO
  276. }

  278. /**
  279.  * @brief 最大的收获就是函数相互调用！感觉挺麻烦的，调试也麻烦，稍微写错了，就死循环！或者失败！
  280.  */
  281. int main(void)
  282. {
  283.     linkerList * plinkerList = initLinker();
  284.     traverseLinker(plinkerList);

  286.     return EXIT_SUCCESS;
  287. }
自拍..
.
阅读(4326) | 评论(0) | 转发(1) |
0

上一篇：适配器模式【ADAPTER  PATTERN 】

下一篇：服务器模型

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6