二级链表的定义和用法

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>
    
15. 
    
16. /**
    
17.  * @brief 二级链表
    
18.  */
    
19. typedef struct _Menu Menu;
    
20. typedef struct _ChildMenu ChildMenu;
    
21. 
    
22. /// < 第二级链表
    
23. struct _ChildMenu
    
24. {
    
25.     char * m_name;
    
26.     ChildMenu * cNext;
    
27. };
    
28. 
    
29. /// < 第一级链表
    
30. struct _Menu
    
31. {
    
32.     char * m_name;
    
33.     Menu * pMenu;
    
34. 
    
35.     int count;
    
36.     ChildMenu * pChildMenu;
    
37. };
    
38. 
    
39. /// < 初始化链表
    
40. Menu * initMenu()
    
41. {
    
42.     Menu * pHead = NULL;
    
43.     Menu * pNext = NULL;
    
44.     ChildMenu * pcHead = NULL;
    
45. 
    
46.     int i , j;
    
47. 
    
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));
    
54. 
    
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");
    
60. 
    
61.         pMenu->count = 2;
    
62. 
    
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.         }
    
74. 
    
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");
    
85. 
    
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.     }
    
100. 
     
101.     return pHead;
     
102. }
     
103. 
     
104. /// < 二级链表的遍历
     
105. void traverse_linker(const Menu * head)
     
106. {
     
107.     const Menu * p = head;
     
108.     ChildMenu * q;
     
109.     int i;
     
110. 
     
111.     if (!head)
     
112.         return ;
     
113. 
     
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');
     
124. 
     
125.         p = p->pMenu;
     
126.     }
     
127. }
     
128. 
     
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. }
     
162. 
     
163. /**
     
164.  * @brief 鉴于所使用的环境，carbide.c ；所以用gcc调试，用symbian os application进行内存泄漏检查！
     
165.  * 突然发现symbian模拟器运行程序挺爽的，关闭后检查你的内存泄漏。挺好，应该还有很多工具可以检查，目前
     
166.  * 这个不错！不过调试的话，看内存，看变量就可以了，不需要去打印哈！你懂的..
     
167.  */
     
168. int main()
     
169. {
     
170.     Menu * pMenu = initMenu();
     
171. 
     
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);
     
176. 
     
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. }

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！