7种数据结构

次序表

sqlite.h

1. #ifndef __SEQLIST_H__
2. #define __SEQLIST_H__  
4. typedef struct        person {
5.         char name[32];
6.         char sex;
7.         int age;
8.         int score;
9. }DATATYPE;
10. // typedef int DATAYPE;
11. typedef struct list {
12.         DATATYPE *head;
13.         int tlen;
14.         int clen;
15. }SeqList;
17. SeqList *CreateSeqList(int len);
18. int DestroySeqList(SeqList *list);
19. int ShowSeqList(SeqList *list);
20. int InsertTailSeqList(SeqList *list, DATATYPE* data);
21. int IsFullSeqList(SeqList *list);
22. int IsEmptySeqList(SeqList *list);
23. int InsertPosSeqList(SeqList *list, DATATYPE* data, int pos);
24. int FindSeqList(SeqList *list, char *name);
25. int ModifySeqList(SeqList *list, char *old, DATATYPE *newdata);
26. int DeleteSeqList(SeqList *list, char *name);
27. int ClearSeqList(SeqList *list);
28. int GetSizeSeqList(SeqList*list);
29. DATATYPE* GetDataType(SeqList*list,int pos);
30. #endif

复制代码

seqlite.c

1. #include "seqlist.h"
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. SeqList *CreateSeqList(int len)
6. {
7.     SeqList* sl = (SeqList*)malloc(sizeof(SeqList));
8.     if(NULL == sl)
9.     {
10.         printf("malloc 1 error\n");
11.         return NULL;
12.     }
14.     sl->head = (DATATYPE*)malloc(sizeof(DATATYPE)*len);
15.     if(NULL == sl->head)
16.     {
17.         printf("malloc 1 error\n");
18.         return NULL;
19.     }
22.     sl->tlen = len;
23.     sl->clen = 0;
24.     return sl;
26. }
27. int InsertTailSeqList(SeqList *list, DATATYPE* data)
28. {   
29.    
30.     if(IsFullSeqList(list))
31.     {
32.         return 1;
33.     }
34.     //strcpy
35.     memcpy(&list->head[list->clen],data,sizeof(DATATYPE));
36.     list->clen++;
37.     return 0;
38. }
39. int IsFullSeqList(SeqList* list)
40. {
41.     return list->clen  == list->tlen ;
42. }
43. int GetSizeSeqList(SeqList*list)
44. {
45.     return list->clen ;
46. }
47. int ShowSeqList(SeqList *list)
48. {
50.     int i = 0 ;
51.     int len = GetSizeSeqList(list);
52.     for(i = 0;i<len;i++)
53.     {
54.         
55.         printf("%s %c %d %d\n",list->head[i].name,
56.                list->head [i].sex,list->head[i].age,list->head[i].score );
57.     }
58. }
60. int IsEmptySeqList(SeqList *list)
61. {
62.     return 0 ==list->clen ;
63. }
65. int InsertPosSeqList(SeqList *list, DATATYPE *data, int pos)
66. {
68.     if(pos<0 ||pos>list->clen)
69.     {
70.         return 1;
71.     }
73.     if(IsFullSeqList(list))
74.     {
75.         return 1;
76.     }
78.     for(int i= list->clen ;i>pos;i--)
79.     {
80.         list->head[i]= list->head[i-1];
81.     }
82.     memcpy(&list->head[pos],data,sizeof(DATATYPE));
83.     list->clen ++;
84.     return 0;
85. }
86. int FindSeqList(SeqList *list, char *name)
87. {
88.     int len = GetSizeSeqList(list);
89.     int i = 0 ;
90.     for(i=0;i<len;i++)
91.     {
92.    
93.         if(0== strcmp(list->head [i].name,name))
94.         {
95.         
96.             return i;
97.         }
98.     }
100.     return -1;
101. }
102. DATATYPE* GetDataType(SeqList*list,int pos)
103. {
105.     return &list->head[pos];
106. }
107. int ClearSeqList(SeqList *list)
108. {
110.     list->clen = 0;
111.     return 0;   
112. }
114. int DestroySeqList(SeqList *list)
115. {
117.     free(list->head);
118.     free(list);
119.     return 0;
120. }
122. int ModifySeqList(SeqList *list, char *old, DATATYPE *newdata)
123. {
125.     int i = FindSeqList(list,old);
126.     if(-1 == i)
127.     {
128.         return 1;
129.     }
131.     //list->head[i] = *newdata;
132.     memcpy(&list->head[i],newdata,sizeof(DATATYPE));
133.     return 0;
135. }
137. int DeleteSeqList(SeqList *list, char *name)
138. {
140.     int pos = FindSeqList(list, name);
141.     if(-1 == pos)
142.     {
143.         return 1;
144.     }
145.     int len  =GetSizeSeqList(list);
146.     int i = 0 ;
147.     for(i=pos;i<len;i++)   
148.     {
149.          memcpy(&list->head[i],&list->head[i+1],sizeof(DATATYPE));
150.     }
151.     list->clen--;
152.     return 0;
153. }

复制代码

单链表

linklist.c

1. #include "linklist.h"
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
6. LinkList *CreateLinkList() {
7.   LinkList *ll = (LinkList *)malloc(sizeof(LinkList));
8.   if (NULL == ll) {
9.     printf("CreateLinkList malloc\n");
10.     return NULL;
11.   }
12.   ll->head = NULL;
13.   ll->clen = 0;
14.   return ll;
15. }
17. int InsertHeadLinkList(LinkList *list, DATATYPE *data) {
18.   LinkNode *newnode = (LinkNode *)malloc(sizeof(LinkNode));
19.   if (NULL == newnode) {
20.     printf("InsertHeadLinkList malloc\n");
21.     return 1;
22.   }
23.   memcpy(&newnode->data, data, sizeof(DATATYPE));
24.   newnode->next = NULL;
26.   if (IfEmptyLinkList(list)) // empty
27.   {
28.     list->head = newnode;
29.   } else {
30.     newnode->next = list->head;
31.     list->head = newnode;
32.   }
34.   list->clen++;
36.   return 0;
37. }
39. int IfEmptyLinkList(LinkList *list) { return 0 == list->clen; }
41. int ShowLinkList(LinkList *list) {
43.   LinkNode *tmp = list->head;
44.   while (tmp) {
45.     printf("%s %d\n", tmp->data.name, tmp->data.age);
46.     tmp = tmp->next; // i++
47.   }
48.   return 0;
49. }
51. // LinkNode *FindLinkList(LinkList *list, char *name)
52. LinkNode *FindLinkList(LinkList *list, PFUN fun, void *arg) {
53.   LinkNode *tmp = list->head;
54.   while (tmp) {
56.     // if(0==strcmp(tmp->data.name,name))
57.     if (fun(&tmp->data, arg)) {
59.       return tmp;
60.     }
61.     tmp = tmp->next; // i++
62.   }
63.   return NULL;
64. }
66. int InsertTailLinkList(LinkList *list, DATATYPE *data) {
68.   LinkNode *newnode = (LinkNode *)malloc(sizeof(LinkNode));
69.   if (NULL == newnode) {
70.     printf("InsertTailLinkList malloc\n");
71.     return 1;
72.   }
73.   memcpy(&newnode->data, data, sizeof(DATATYPE));
74.   newnode->next = NULL;
75.   if (IfEmptyLinkList(list)) {
76.     list->head = newnode;
77.   } else {
78.     LinkNode *tmp = list->head;
79.     while (tmp->next) {
80.       tmp = tmp->next;
81.     }
82.     tmp->next = newnode;
83.   }
85.   list->clen++;
86.   return 0;
87. }
89. int InsertPosLinkList(LinkList *list, DATATYPE *data, int pos) {
91.   int len = GetSizeLinkList(list);
92.   if (pos < 0 || pos > len) {
93.     return 1;
94.   }
96.   if (0 == pos) {
98.     return InsertHeadLinkList(list, data);
99.   } else if (pos == len) {
101.     return InsertTailLinkList(list, data);
102.   } else //中间位置
103.   {
105.     LinkNode *newnode = (LinkNode *)malloc(sizeof(LinkNode));
106.     if (NULL == newnode) {
107.       printf("InsertTailLinkList malloc\n");
108.       return 1;
109.     }
110.     memcpy(&newnode->data, data, sizeof(DATATYPE));
111.     newnode->next = NULL;
112.     LinkNode *tmp = list->head;
113.     int i = 0;
114.     for (i = 0; i < pos - 1; i++) {
115.       tmp = tmp->next;
116.     }
117.     newnode->next = tmp->next;
118.     tmp->next = newnode;
119.   }
120.   list->clen++;
121.   return 0;
122. }
124. int GetSizeLinkList(LinkList *list) { return list->clen; }
126. int DeleteHeadLinklist(LinkList *list) {
128.   if (IfEmptyLinkList(list)) {
129.     return 1;
130.   }
131.   LinkNode *tmp = list->head;
132.   list->head = tmp->next;
133.   free(tmp);
134.   list->clen--;
135.   return 0;
136. }
138. int DeleteTailLinkList(LinkList *list) {
140.   if (IfEmptyLinkList(list)) {
141.     return 1;
142.   }
143.   int len = GetSizeLinkList(list);
144.   if (1 == len) {
145.     free(list->head);
146.     list->head = NULL;
147.   } else {
148.     LinkNode *tmp = list->head;
149.     LinkNode *tmp1 = list->head;
150.     while (tmp->next) {
151.       tmp1 = tmp; // tmp1 比tmp晚一步
152.       tmp = tmp->next;
153.     }
154.     free(tmp);
155.     tmp1->next = NULL;
156.   }
158.   list->clen--;
159.   return 0;
160. }
162. int DeletePosLinkList(LinkList *list, int pos) {
164.   int len = GetSizeLinkList(list);
165.   if (IfEmptyLinkList(list)) {
166.     return 1;
167.   }
168.   if (0 == pos) {
169.     DeleteHeadLinklist(list);
170.   } else if (len - 1 == pos) // len 4
171.   {
172.     DeleteTailLinkList(list);
173.   } else //中间
174.   {
175.     LinkNode *tmp = list->head;
176.     LinkNode *tmp1 = list->head;
177.     for (int i = 0; i < pos; i++) {
178.       tmp1 = tmp;
179.       tmp = tmp->next;
180.     }
181.     tmp1->next = tmp->next;
182.     free(tmp);
183.     list->clen--;
184.   }
185.   return 0;
186. }
188. int ModifyLinkList(LinkList *list, PFUN fun, void *arg, DATATYPE *newdata) {
190.   LinkNode *tmp = FindLinkList(list, fun, arg);
191.   if (NULL == tmp) {
192.     return 1;
193.   }
195.   memcpy(&tmp->data, newdata, sizeof(DATATYPE));
196.   return 1;
197. }
199. int DestroyLinkList(LinkList *list) {
201.   int len = GetSizeLinkList(list);
202.   for (int i = 0; i < len; i++) {
204.     DeleteHeadLinklist(list);
205.   }
206.   free(list);
207.   return 0;
208. }
210. LinkNode *FindMidLinkList(LinkList *list) {
211.   if (IfEmptyLinkList(list)) {
212.     return NULL;
213.   }
214.   LinkNode *pfast = list->head;
215.   LinkNode *pslow = list->head;
216.   while (pfast) {
217.     pfast = pfast->next; // pfast = pfast->next->next;
218.     if (pfast) {
219.       pfast = pfast->next;
220.       pslow = pslow->next;
221.     } else {
222.       break;
223.     }
224.   }
225.   return pslow;
226. }
228. LinkNode *FindRevKLinkList(LinkList *list, int k) {
230.   if (IfEmptyLinkList(list)) {
231.     return NULL;
232.   }
233.   LinkNode *pfast = list->head;
234.   LinkNode *pslow = list->head;
235.   int i = 0;
236.   for (i = 0; i < k; i++) {
237.     pfast = pfast->next;
238.     if (NULL == pfast) {
239.       return pslow;
240.     }
241.   }
243.   while (pfast) {
244.     pfast = pfast->next;
245.     // if (NULL==pfast)
246.     // {
247.     //   break;
248.     // }
250.     pslow = pslow->next;
251.   }
253.   return pslow;
254. }
256. int RevertLinkList(LinkList *list) {
257.   LinkNode *prev = NULL;
258.   LinkNode *tmp = list->head;
259.   LinkNode *next = list->head->next;
260.   while (1) {
261.     tmp->next = prev;
262.     prev = tmp;
263.     tmp = next;
264.     if (NULL == tmp) {
265.       break;
266.     }
267.     next = next->next;
268.   }
269.   list->head = prev;
270.   return 0;
271. }
273. int InsertSortLinkList(LinkList *list)
274. {
276.   LinkNode* phead = list->head;
277.   LinkNode* pinsert = phead->next;
278.   LinkNode* pnext = pinsert->next;
279.   phead->next = NULL;
281.   while(1)
282.    {
283.     phead = list->head;
284.     while(phead->next != NULL && pinsert->data.age > phead->data.age &&
285.           pinsert->data.age > phead->next->data.age)
286.     {
287.       phead = phead->next;
288.     }
290.     if(pinsert->data .age <phead -> data.age) // head insert
291.     {
292.       pinsert->next = list->head;
293.       list->head = pinsert;
294.     }
295.     else
296.     {
297.       pinsert->next = phead->next;
298.       phead->next = pinsert;
299.     }
301.     pinsert = pnext;
302.     if(NULL == pinsert)
303.     { break; }
304.     pnext = pnext->next;
305.    
306.   }
307.   return 0;
308. }

复制代码

linklist.h

1. #ifndef __LINKLIST_H__
2. #define __LINKLIST_H__
5. typedef struct person
6. {
7.         char name[32];
8.         char sex;
9.         int age;
10.         int score;
11. }DATATYPE;
13. typedef struct node
14. {
15.         DATATYPE data;
16.         struct node *next;
17. }LinkNode;
18. //typedef int u32;
19. typedef struct list
20. {
21.         LinkNode *head;
22.                 int clen;
23. }LinkList;
24. typedef int (*PFUN)(DATATYPE*,void* arg);
25. LinkList *CreateLinkList();
26. int InsertHeadLinkList(LinkList *list, DATATYPE *data);
27. int ShowLinkList(LinkList *list);
28. //LinkNode *FindLinkList(LinkList *list, char *name);
29. LinkNode *FindLinkList(LinkList *list, PFUN fun, void * arg);
30. int DeleteHeadLinklist(LinkList *list);
31. int DeleteTailLinkList(LinkList *list);
32. int DeletePosLinkList(LinkList *list, int pos);
33. int ModifyLinkList(LinkList *list,  PFUN fun, void * arg,DATATYPE*newdata);
34. int DestroyLinkList(LinkList *list);
35. int InsertTailLinkList(LinkList *list, DATATYPE *data);
36. int IfEmptyLinkList(LinkList *list);
37. int InsertPosLinkList(LinkList *list, DATATYPE *data,int Pos);
38. int GetSizeLinkList(LinkList *list);
40. LinkNode* FindMidLinkList(LinkList *list);
41. LinkNode* FindRevKLinkList(LinkList *list,int k);
42. int RevertLinkList(LinkList *list);
43. int InsertSortLinkList(LinkList *list) ;
44. #endif  // /__LINKLIST_H__/ !

复制代码

双链表

doulinklist.c

1. #include "doulinklist.h"
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
6. DouLinkList *CreateDouLinkList() {
7.   DouLinkList *dl = (DouLinkList *)malloc(sizeof(DouLinkList));
8.   if (NULL == dl) {
9.     printf("CreateDouLinkList malloc\n");
10.     return NULL;
11.   }
13.   dl->head = NULL;
14.   dl->clen = 0;
15.   return dl;
16. }
17. int IsEmptyDouLinkList(DouLinkList *list) { return 0 == list->clen; }
18. int GetSizeDouLinkList(DouLinkList *list) { return list->clen; }
20. int InsertHeadDouLinkList(DouLinkList *list, DATATYPE *data) {
21.   DouLinkNode *newnode = (DouLinkNode *)malloc(sizeof(DouLinkNode));
22.   if (NULL == newnode) {
23.     printf("InsertHeadDouLinkList malloc\n");
24.     return 1;
25.   }
27.   memcpy(&newnode->data, data, sizeof(DATATYPE));
28.   newnode->next = NULL;
29.   newnode->prev = NULL;
30.   if (IsEmptyDouLinkList(list)) {
31.     list->head = newnode;
32.   } else {
33.     newnode->next = list->head;
34.     list->head->prev = newnode;
35.     list->head = newnode;
36.   }
37.   list->clen++;
38.   return 0;
39. }
41. int ShowDouLinkList(DouLinkList *list, SHOW_DIR dir) {
42.   DouLinkNode *tmp = list->head;
43.   if (DIR_FORWARD == dir) {
44.     while (tmp) {
45.       printf("%s %d\n", tmp->data.name, tmp->data.score);
46.       tmp = tmp->next;
47.     }
48.   } else {
49.     while (tmp->next) {
50.       tmp = tmp->next;
51.     }
52.     while (tmp) {
53.       printf("%s %d\n", tmp->data.name, tmp->data.score);
54.       tmp = tmp->prev;
55.     }
56.   }
58.   return 0;
59. }
61. int InsertTailDouLinkList(DouLinkList *list, DATATYPE *data) {
62.   if (IsEmptyDouLinkList(list)) {
63.     return InsertHeadDouLinkList(list, data);
64.   }
66.   DouLinkNode *tmp = list->head;
67.   while (tmp->next) {
68.     tmp = tmp->next;
69.   }
70.   DouLinkNode *newnode = (DouLinkNode *)malloc(sizeof(DouLinkNode));
71.   if (NULL == newnode) {
72.     printf("InsertTailDouLinkList malloc\n");
73.     return 1;
74.   }
75.   memcpy(&newnode->data, data, sizeof(DATATYPE));
76.   newnode->next = NULL;
77.   newnode->prev = NULL;
79.   newnode->prev = tmp;
80.   tmp->next = newnode;
82.   list->clen++;
83.   return 0;
84. }
85. /*
86.     func:
87.     param:
88.     retval:
89. */
90. int InsertPosDouLinkList(DouLinkList *list, DATATYPE *data, int pos) {
91.   int len = GetSizeDouLinkList(list);
92.   if (pos < 0 || pos > len) {
93.     return 1;
94.   }
96.   if (0 == pos) {
97.     return InsertHeadDouLinkList(list, data);
98.   } else if (len == pos) {
99.     return InsertTailDouLinkList(list, data);
100.   } else {
101.     DouLinkNode *tmp = list->head;
102.     for (int i = 0; i < pos; i++) {
103.       tmp = tmp->next;
104.     }
105.     DouLinkNode *newnode = malloc(sizeof(DATATYPE));
106.     if (NULL == newnode) {
107.       printf("InsertPosDouLinkList malloc\n");
108.       return 1;
109.     }
110.     memcpy(&newnode->data, data, sizeof(DATATYPE));
111.     newnode->next = NULL;
112.     newnode->prev = NULL;
114.     newnode->next = tmp;
115.     newnode->prev = tmp->prev;
116.     tmp->prev = newnode;
117.     newnode->prev->next = newnode;
118.   }
119.   list->clen++;
120.   return 0;
121. }
123. int DeleteHeadDouLinkList(DouLinkList *list) {
124.   if (IsEmptyDouLinkList(list)) {
125.     return 1;
126.   }
127.   DouLinkNode *tmp = list->head;
128.   list->head = list->head->next;
129.   if (list->head != NULL) {
130.     list->head->prev = NULL;
131.   }
133.   free(tmp);
134.   list->clen--;
135.   return 0;
136. }
137. int DeleteTailDouLinkList(DouLinkList *list) {
138.   if (IsEmptyDouLinkList(list)) {
139.     return 1;
140.   }
141.   DouLinkNode *tmp = list->head;
142.   while (tmp->next) {
143.     tmp = tmp->next;
144.   }
145.   if (tmp->prev != NULL) {
146.     tmp->prev->next = NULL;
147.   } else {
148.     list->head = NULL;
149.   }
150.   free(tmp);
151.   list->clen--;
152.   return 0;
153. }
155. int DeletePosDouLinkList(DouLinkList *list, int pos) {
156.   int len = GetSizeDouLinkList(list);
157.   if (pos < 0 || pos > len - 1) {
158.     return 1;
159.   }
161.   if (0 == pos) {
162.     return DeleteHeadDouLinkList(list);
163.   } else if (pos == len - 1) {
164.     return DeleteTailDouLinkList(list);
166.   } else // mid del
167.   {
168.     DouLinkNode *tmp = list->head;
169.     for (int i = 0; i < pos; i++) {
170.       tmp = tmp->next;
171.     }
172.     tmp->next->prev = tmp->prev;
173.     tmp->prev->next = tmp->next;
175.     free(tmp);
176.     list->clen--;
177.   }
178.   return 0;
179. }
182. DouLinkNode *FindDouLinkList(DouLinkList *list, char *name)
183. {
185.   if(IsEmptyDouLinkList(list))
186.   {
187.     return NULL;
188.   }
189.   DouLinkNode* tmp = list->head;
191.   while(tmp)
192.   {
193.     if(0 == strcmp(tmp->data.name,name))
194.     {
195.       return tmp;
196.     }
197.     tmp=tmp->next;
198.   }
199.   return NULL;
200. }
202. int ModifyDouLinkList(DouLinkList *list, char *name, DATATYPE* data)
203. {
204.   DouLinkNode* tmp = FindDouLinkList(list, name);
205.   if(NULL == tmp)
206.   {
207.     return 1;
208.   }
209.   memcpy(&tmp->data,data,sizeof(DATATYPE));
210.   return 0;
211. }
213. int DestroyDouLinkList(DouLinkList *list)
214. {
215.   int len = GetSizeDouLinkList(list);
216.   for(int i = 0 ;i<len;i++)
217.   {
218.     DeleteHeadDouLinkList(list);
219.   }
221.   free(list);
222.   return 0;
223. }

复制代码

doulinklist.h

1. #ifndef __DOULINKLIST_H__
2. #define __DOULINKLIST_H__
3. typedef struct person {
4.         char name[32];
5.         char sex;
6.         int age;
7.         int score;
8. }DATATYPE;
10. typedef struct dounode {
11.         DATATYPE data;
12.         struct dounode *next,*prev;
13. }DouLinkNode;
15. typedef struct list {
16.         DouLinkNode *head;
17.         int clen;
18. }DouLinkList;
19. typedef enum{DIR_FORWARD,DIR_BACKWARD} SHOW_DIR;
20. DouLinkList *CreateDouLinkList();
21. int InsertHeadDouLinkList(DouLinkList *list, DATATYPE* data);
22. int InsertTailDouLinkList(DouLinkList *list, DATATYPE* data);
23. int InsertPosDouLinkList(DouLinkList *list, DATATYPE* data,int pos);
24. int ShowDouLinkList(DouLinkList *list,SHOW_DIR dir);
25. DouLinkNode *FindDouLinkList(DouLinkList *list, char *name);
26. int DeleteHeadDouLinkList(DouLinkList *list) ;
27. int DeleteTailDouLinkList(DouLinkList *list);
28. int DeletePosDouLinkList(DouLinkList *list,int pos);
29. int ModifyDouLinkList(DouLinkList *list, char *name, DATATYPE* data);
30. int DestroyDouLinkList(DouLinkList *list);
31. int IsEmptyDouLinkList(DouLinkList *list);
32. int GetSizeDouLinkList(DouLinkList *list);
34. #endif

复制代码

链式栈

linkstack.c

1. #include "linkstack.h"
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
6. LinkStack* CreateLinkStack()
7. {
8.   LinkStack* ls = (LinkStack*)malloc(sizeof(LinkStack));
9.   if(NULL == ls)
10.   {
11.     printf("CreateLinkStack malloc");
12.     return NULL;
13.   }
14.   ls->top = NULL;
15.   ls->clen= 0 ;
16.   return ls;
17.   
18. }
20. int PushLinkStack(LinkStack*ls,DATATYPE*data)
21. {
23.   LinkStackNode* newnode = (LinkStackNode*)malloc(sizeof(LinkStackNode));
24.   if(NULL == newnode)
25.   {
26.     printf("PushLinkStack malloc");
27.     return 1;
28.   }
29.   memcpy(&newnode->data,data,sizeof(DATATYPE));
30.   newnode->next = NULL;
32.   newnode->next = ls->top;
33.   ls->top = newnode;
35.   ls->clen++;
36.   return 0;
38. }
40. int IsEmptyLinkStack(LinkStack*ls)
41. {
42.   return 0 == ls->clen;
43. }
44. int PopLinkStack(LinkStack*ls)
45. {
46.   if(IsEmptyLinkStack(ls))
47.   {
48.     return 1;
49.   }
51.   LinkStackNode* tmp = ls->top;
52.   ls->top = ls->top->next;
53.   free(tmp);
54.   ls->clen--;
55.   return 0;
56. }
58. DATATYPE*GetTopLinkStack(LinkStack*ls)
59. {
60.    if(IsEmptyLinkStack(ls))
61.   {
62.     return NULL;
63.   }
64.   return &ls->top->data;
65. }
66. int GetSizeLinkStack(LinkStack*ls)
67. {
68.   return ls->clen;
69. }

复制代码

linkstack.h

1. #ifndef __LINKSTACK_H__
2. #define __LINKSTACK_H__
5. typedef struct person
6. {
7.         char name[32];
8.         char sex;
9.         int age;
10.         int score;
11. }DATATYPE;
13. typedef struct stacknode
14. {
15.         DATATYPE data;
16.         struct stacknode *next;
17. }LinkStackNode;
19. typedef struct list
20. {
21.         LinkStackNode *top;// 和单向链表中的head,一个意思
22.                 int clen;
23. }LinkStack;
24. LinkStack* CreateLinkStack();
25. int DestroyLinkStack(LinkStack*ls);
26. int PushLinkStack(LinkStack*ls,DATATYPE*data);
27. int PopLinkStack(LinkStack*ls);
28. int IsEmptyLinkStack(LinkStack*ls);
29. DATATYPE*GetTopLinkStack(LinkStack*ls);
30. int GetSizeLinkStack(LinkStack*ls);
31. #endif  // /__LINKLIST_H__/ !

复制代码

队列

SeqQueue.c

1. #include "SeqQueue.h"
2. SeqQueue *CreateSeqQueue(int len)
3. {
5.     SeqQueue* sq = (SeqQueue*)malloc(sizeof(SeqQueue));
6.     if(NULL == sq)
7.     {
8.         printf("CreateSeqQueue malloc\n");
9.         return NULL;
10.     }
12.     sq->ptr  = (DATATYPE*)malloc(sizeof(DATATYPE)*len);
13.     if(NULL == sq->ptr )
14.     {
15.         
16.         printf("CreateSeqQueue malloc2\n");
17.         return NULL;
18.     }
19.     sq->tlen = len;
20.     sq->head  = 0 ;
21.     sq->tail = 0;
22.     return sq;
23. }
26. int IsEmptySeqQueue(SeqQueue *queue)
27. {
28.     return queue->head == queue->tail ;
29. }
30. int IsFullSeqQueue(SeqQueue *queue)
31. {
32.     return (queue->tail +1) % queue->tlen  == queue->head;
33. }
34. int QuitSeqQueue(SeqQueue *queue)
35. {
36.     if(IsEmptySeqQueue(queue))
37.     {
38.         return 1;
39.     }
41.     queue->head = (queue->head+1)%queue->tlen;
42.     return 0;
43. }
44. int EnterSeqQueue(SeqQueue *queue, DATATYPE *data)
45. {
46.     if(IsFullSeqQueue(queue))
47.     {
48.         return 1;
49.     }
51.     memcpy(&queue->ptr[queue->tail],data,sizeof(DATATYPE));
52.     queue->tail = (queue->tail +1) % queue->tlen ;
53.     return 0;
54. }
55. DATATYPE* GetHeadSeqQueue(SeqQueue* que)
56. {
57.      if(IsEmptySeqQueue(que))
58.     {
59.         return NULL;
60.     }
62.     return &que->ptr[que->head];
63. }

复制代码

SeqQueue.h

1. #ifndef __SEQQUEUE_H__
2. #define __SEQQUEUE_H__
4. #include <stdio.h>
5. #include <stdlib.h>
6. #include <string.h>
8. typedef int DATATYPE;
9. typedef struct queue {
10.         DATATYPE *ptr;
11.         int tlen;
12.         int head;
13.         int tail;
14. }SeqQueue;
16. SeqQueue *CreateSeqQueue(int len);
17. int DestroySeqQueue(SeqQueue *queue);
18. int QuitSeqQueue(SeqQueue *queue);
19. int EnterSeqQueue(SeqQueue *queue, DATATYPE *data);
20. int IsEmptySeqQueue(SeqQueue *queue);
21. int IsFullSeqQueue(SeqQueue *queue);
22. DATATYPE* GetHeadSeqQueue(SeqQueue* que);
24. #endif

复制代码

树

tree.c

1. #include <stdio.h>
2. #include <stdlib.h>
3. typedef char DATATYPE;
4. typedef struct BiTNode  /* 结点结构 */
5. {
6.    DATATYPE data;                /* 结点数据 */
7.    struct BiTNode *lchild,*rchild; /* 左右孩子指针 */
8. }BiTNode;
9. char data[]="Ab#df###ceg##h###";
10. int ind =  0;
11. void CreateBiTree(BiTNode** root)
12. {
13.     char c = data[ind++];
14.     if('#'==c)
15.     {
16.         *root = NULL;
17.         return ;
18.     }
19.     *root = (BiTNode*)malloc(sizeof(BiTNode));
20.     if(NULL == *root)
21.     {
22.         perror("malloc");
23.         return ;
24.     }
25.     (*root)->data = c;
26.     CreateBiTree(&((*root)->lchild));
27.     CreateBiTree(&((*root)->rchild));
28.     return ;
29.    
30. }
31. void DestroyBiTree(BiTNode * root)
32. {
33.     if(NULL ==root)
34.     {
35.         return ;
36.     }
37.     DestroyBiTree(root->lchild);
38.     DestroyBiTree(root->rchild);
39.     free(root);
42. }
44. void PreOrderTraverse(BiTNode * root)
45. {
46.     if(NULL == root)
47.     {
48.         return ;
49.     }
50.     printf("%c",root->data);
51.     PreOrderTraverse(root->lchild);
52.     PreOrderTraverse(root->rchild);
53. }
54. void InOrderTraverse(BiTNode * root)
55. {
57.     if(NULL == root)
58.     {
59.         return ;
60.     }
61.     InOrderTraverse(root->lchild);
62.     printf("%c",root->data);
63.     InOrderTraverse(root->rchild);
65. }
66. void PostOrderTraverse(BiTNode * root)
67. {
68.     if(NULL == root)
69.     {
70.         return ;
71.     }
72.     PostOrderTraverse(root->lchild);
73.     PostOrderTraverse(root->rchild);
74.     printf("%c",root->data);
76. }
78. int        main(int argc, char **argv)
79. {
80.    
81.     BiTNode* root=NULL;
82.     CreateBiTree(&root);
83.     PreOrderTraverse(root);
84.     printf("\n");
86.     InOrderTraverse(root);
87.     printf("\n");
88.     PostOrderTraverse(root);
89.     printf("\n");
90.     DestroyBiTree(root);
91.     root = NULL;
92.     //system("pause");
93.     return 0;
94. }

复制代码

哈希表

hash.c

1. #include <stdio.h>
2. #include <stdlib.h>
4. typedef int DATATYPE;
6. typedef struct
7. {
8.     DATATYPE* head;
9.     int tlen;
10. }HS_TABLE;
12. HS_TABLE* CreateHsTable(int len)
13. {
14.     HS_TABLE* hs = malloc(sizeof(HS_TABLE));
15.     if(NULL == hs)
16.     {
17.         perror("CreateHsTable malloc1");
18.         return NULL;
19.     }
21.     hs->head = malloc(sizeof(DATATYPE)*len);
22.     if(NULL == hs->head)
23.     {
24.         perror("CreateHsTable malloc2");
25.         return NULL;
26.     }
27.     hs->tlen = len;
28.     int i = 0 ;
29.     for(i=0;i<len;i++)
30.     {
31.         hs->head[i] = -1;
32.     }
33.     return hs;
34. }
35. int HS_fun(HS_TABLE* hs,DATATYPE* data)
36. {
37.     return *data %hs->tlen;
38. }
39. int HS_insert(HS_TABLE* hs,DATATYPE* data)
40. {
41.     int ind = HS_fun(hs,data);
42.     while(hs->head[ind]!= -1)
43.     {
44.         printf("values:%d  conllision pos:%d\n",*data,ind);
45.         ind = (ind+1) %hs->tlen;
46.     }
47.     hs->head[ind] = *data;
48.     return 0;
49. }
50. int HS_search(HS_TABLE* hs,DATATYPE* data)
51. {
52.     int ind = HS_fun(hs,data);
53.     int oldind = ind;
54.     while(hs->head[ind]!=*data )
55.     {
56.         ind = (ind+1) %hs->tlen;
57.         if(oldind == ind)
58.         {
59.             return -1;
60.         }
61.     }
63.     return ind;
64. }
65. int        main(int argc, char **argv)
66. {
67.    
68.     HS_TABLE* hs = CreateHsTable(12);
69.     int data[12]={12,67,56,16,25,37,22,29,15,47,48,34};
70.     int i = 0;
71.     for(i=0;i<12;i++)
72.     {
73.         HS_insert(hs, &data[i]);
74.     }
76.     int want_int = 44;
77.     int ind = HS_search(hs, &want_int);
78.     if(-1 == ind)
79.     {
80.         printf("cant find %d\n",want_int);
81.     }
82.     else
83.     {
84.         printf("find it ,pos %d\n",ind);
85.     }
86.    
87.     return 0;
88. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。