双向链表

view plaincopy to clipboardprint?

1. #ifndef _LIST_H_   
2. #define _LIST_H_   
3. #include <stdio.h>   
4. #define _ASSERT_RET(cond, ret) if (!(cond)){printf("file: %s,line: %d/n", __FILE__, __LINE__);return ret;}else{}   
5. typedef struct _VALUE_{   
6.     void *pvData;   
7.     unsigned long udwLength;   
8. }_VALUE_;   
9. typedef struct _ListNode{   
10.     struct _VALUE_ tData;   
11.     struct _ListNode *prevPtr;   
12.     struct _ListNode *nextPtr;   
13. }*_PLISTNODE, _LISTNODE;   
14. typedef struct _List{   
15.     _PLISTNODE ptrNodeHead;   
16.     _PLISTNODE ptrNodeEnd;   
17.     size_t iSize;    
18. }*PLIST, LIST;   
19. PLIST InitList(PLIST ptList);   
20. _PLISTNODE FindNode(PLIST ptList, _VALUE_ *ptToFind);   
21. _PLISTNODE InsertPos(PLIST ptList, unsigned long udwPos, _VALUE_ *pToInsert);   
22. void For_each(PLIST ptNode, void (*DoSome)(_VALUE_ *pvalue));   
23. PLIST SortList(PLIST ptList, int(*compare)(_VALUE_ *LeftValPtr, _VALUE_ *RightValPtr));   
24. _PLISTNODE DeleteNode(_PLISTNODE ptToDelete);   
25. void ReleaseAll(PLIST ptrList);   
26. _PLISTNODE InsertNode(_PLISTNODE ptInsertBack, _VALUE_ *pToInsert);   
27. #endif  

#ifndef _LIST_H_#define _LIST_H_#include <stdio.h>#define _ASSERT_RET(cond, ret) if (!(cond)){printf("file: %s,line: %d/n", __FILE__, __LINE__);return ret;}else{}typedef struct _VALUE_{ void *pvData; unsigned long udwLength;}_VALUE_;typedef struct _ListNode{ struct _VALUE_ tData; struct _ListNode *prevPtr; struct _ListNode *nextPtr;}*_PLISTNODE, _LISTNODE;typedef struct _List{ _PLISTNODE ptrNodeHead; _PLISTNODE ptrNodeEnd; size_t iSize; }*PLIST, LIST;PLIST InitList(PLIST ptList);_PLISTNODE FindNode(PLIST ptList, _VALUE_ *ptToFind);_PLISTNODE InsertPos(PLIST ptList, unsigned long udwPos, _VALUE_ *pToInsert);void For_each(PLIST ptNode, void (*DoSome)(_VALUE_ *pvalue));PLIST SortList(PLIST ptList, int(*compare)(_VALUE_ *LeftValPtr, _VALUE_ *RightValPtr));_PLISTNODE DeleteNode(_PLISTNODE ptToDelete);void ReleaseAll(PLIST ptrList);_PLISTNODE InsertNode(_PLISTNODE ptInsertBack, _VALUE_ *pToInsert);#endif

 

 

 

 

view plaincopy to clipboardprint?

1. #include <stdio.h>   
2. #include <stdlib.h>   
3. #include <memory.h>   
4. #include <time.h>   
5. #include "list.h"   
6. PLIST InitList(PLIST ptList)   
7. {   
8.     ptList->ptrNodeHead = NULL;   
9.     ptList->ptrNodeEnd = NULL;   
10.     ptList->iSize = 0;   
11.     return ptList;   
12. }   
13. _PLISTNODE InsertNode(_PLISTNODE ptInsertBack, _VALUE_ *pToInsert)   
14. {   
15.     _PLISTNODE ptNew;   
16.     if (NULL == ptInsertBack){   
17.         return NULL;   
18.     }   
19.        
20.     ptNew = (_PLISTNODE)malloc(sizeof(_LISTNODE));   
21.     ptNew->prevPtr = ptInsertBack;   
22.     ptNew->nextPtr = ptInsertBack->nextPtr;   
23.     ptNew->tData.pvData = malloc(pToInsert->udwLength);   
24.     memcpy(ptNew->tData.pvData, pToInsert->pvData, pToInsert->udwLength);   
25.     ptNew->tData.udwLength = pToInsert->udwLength;   
26.        
27.     ptInsertBack->nextPtr = ptNew;   
28.     if (NULL != ptNew->nextPtr){   
29.         ptNew->nextPtr->prevPtr = ptNew;   
30.     }   
31.        
32.     return ptNew;   
33. }   
34. _PLISTNODE InsertPos(PLIST ptList, unsigned long udwPos, _VALUE_ *pToInsert)   
35. {   
36.     _PLISTNODE ptrNew;   
37.     _ASSERT_RET(ptList != NULL, NULL);   
38.     if (-1 == udwPos)   
39.     {   
40.         ptList->ptrNodeHead = (_PLISTNODE)malloc(sizeof(_LISTNODE));   
41.         ptList->ptrNodeEnd = ptList->ptrNodeHead;   
42.         ++ptList->iSize;   
43.         ptList->ptrNodeHead->nextPtr = NULL;   
44.         ptList->ptrNodeHead->prevPtr = NULL;   
45.         ptList->ptrNodeHead->tData.pvData = malloc(pToInsert->udwLength);   
46.         memcpy(ptList->ptrNodeHead->tData.pvData, pToInsert->pvData, pToInsert->udwLength);   
47.         ptList->ptrNodeHead->tData.udwLength = pToInsert->udwLength;   
48.         return ptList->ptrNodeHead;   
49.     }   
50.     _ASSERT_RET(udwPos < ptList->iSize, NULL);   
51.     if (udwPos * 2 >= ptList->iSize || (0 == udwPos && 1 == ptList->iSize)){   
52.         unsigned long udwrPos = ptList->iSize - udwPos - 1;   
53.         _PLISTNODE ptrNode = ptList->ptrNodeEnd;   
54.         unsigned long udwDes = 0;   
55.         for (; ptrNode != NULL; ptrNode = ptrNode->prevPtr){   
56.             if (udwDes++ == udwrPos){   
57.                 ptrNew = InsertNode(ptrNode, pToInsert);   
58.                 if (ptList->iSize - 1 == udwPos){   
59.                     ptList->ptrNodeEnd = ptrNew;   
60.                 }   
61.                 ++ptList->iSize;   
62.             }   
63.         }   
64.     }else{   
65.         _PLISTNODE ptrNode = ptList->ptrNodeHead;   
66.         unsigned long udwDes = 0;   
67.         for (; ptrNode != NULL; ptrNode = ptrNode->nextPtr){   
68.             if (udwDes++ == udwPos){   
69.                 ptrNew = InsertNode(ptrNode, pToInsert);   
70.                 ++ptList->iSize;   
71.             }   
72.         }   
73.     }   
74.     return ptrNew;   
75. }   
76. _PLISTNODE DeleteNode(_PLISTNODE ptToDelete)   
77. {   
78.     _PLISTNODE toRet;   
79.     ptToDelete->prevPtr->nextPtr = ptToDelete->nextPtr;   
80.     ptToDelete->nextPtr->prevPtr = ptToDelete->prevPtr;   
81.     toRet = ptToDelete->nextPtr;   
82.     free(ptToDelete->tData.pvData);   
83.     free(ptToDelete);   
84.     return toRet;   
85. }   
86. _PLISTNODE FindNode(PLIST ptList, _VALUE_ *ptToFind)   
87. {   
88.     _PLISTNODE ptFirst = ptList->ptrNodeHead;   
89.     for (; ptFirst != NULL; ptFirst = ptFirst->nextPtr){   
90.         if (ptFirst->tData.udwLength == ptToFind->udwLength &&    
91.         !memcmp(ptFirst->tData.pvData, ptToFind->pvData, ptToFind->udwLength)){   
92.             return ptFirst;   
93.         }   
94.     }   
95.        
96.     return NULL;   
97. }   
98. void For_each(PLIST ptNode, void (*DoSome)(_VALUE_ *pvalue))   
99. {   
100.     _PLISTNODE ptFirst = ptNode->ptrNodeHead;   
101.     for (; ptFirst != NULL; ptFirst = ptFirst->nextPtr){   
102.         DoSome(&ptFirst->tData);       
103.     }   
104. }   
105. PLIST SortList(PLIST ptList, int(*compare)(_VALUE_ *LeftValPtr, _VALUE_ *RightValPtr))   
106. {      
107.     _PLISTNODE ptEnd = ptList->ptrNodeEnd;   
108.     _PLISTNODE ptCurEnd = ptEnd;   
109.     _PLISTNODE ptTemp1 = ptList->ptrNodeHead, ptTemp2;   
110.     for (; ptTemp1 != ptEnd; ptTemp1 = ptTemp1->nextPtr){   
111.         for (ptTemp2 = ptList->ptrNodeHead; ptTemp2 != ptCurEnd; ptTemp2 = ptTemp2->nextPtr){   
112.             if (compare(&ptTemp2->tData, &ptTemp2->nextPtr->tData)){   
113.                 _VALUE_ vaTmp;   
114.                 memcpy(&vaTmp, &ptTemp2->tData, sizeof(_VALUE_));   
115.                 memcpy(&ptTemp2->tData, &ptTemp2->nextPtr->tData, sizeof(_VALUE_));   
116.                 memcpy(&ptTemp2->nextPtr->tData, &vaTmp, sizeof(_VALUE_));   
117.             }   
118.         }   
119.         ptCurEnd = ptCurEnd->prevPtr;   
120.     }   
121.        
122.     return ptList;   
123. }   
124. void ReleaseAll(PLIST ptrList)   
125. {   
126.     _PLISTNODE ptTemp;   
127.     _PLISTNODE ptFirst = ptrList->ptrNodeHead;   
128.     for (; ptFirst != NULL; ){   
129.         ptTemp = ptFirst->nextPtr;   
130.         free(ptFirst->tData.pvData);   
131.         free(ptFirst);   
132.         ptFirst = ptTemp;   
133.     }   
134. }   
135. int Greater(_VALUE_ *LeftValPtr, _VALUE_ *RightValPtr)   
136. {   
137.     return (int)(*(long*)LeftValPtr->pvData > *(long*)RightValPtr->pvData);   
138. }   
139. void Print(_VALUE_ *pvalue)   
140. {   
141.     printf("%d ", *(long*)(pvalue->pvData));   
142. }   
143. int main()   
144. {   
145.     LIST        list;   
146.     long        dwVa    = 0;   
147.     long        c       = -1;   
148.     _PLISTNODE  ptNode;   
149.     _VALUE_     value;   
150.     InitList(&list);   
151.     srand((unsigned int)time(NULL));   
152.     value.udwLength = sizeof(dwVa);   
153.        
154.     for (; c != 20; ++c){   
155.         dwVa = rand()%10;   
156.         value.pvData = &dwVa;   
157.         InsertPos(&list, c, &value);   
158.     }   
159.     For_each(&list, Print);   
160.     printf("/n");   
161.        
162.     SortList(&list, Greater);   
163.     For_each(&list, Print);   
164.     printf("/n");   
165.        
166.     dwVa = 19;   
167.     value.pvData = &dwVa;   
168.     _PLISTNODE ptFind = FindNode(&list, &value);   
169.     if (NULL != ptFind){   
170.         printf("%d/n", *(long*)(ptFind->tData.pvData));   
171.     }   
172.     else  
173.     {   
174.         printf("can not find: %d/n", dwVa);      
175.     }   
176.        
177.     ReleaseAll(&list);   
178.     system("pause");   
179.     return 0;   
180. }  

#include <stdio.h>#include <stdlib.h>#include <memory.h>#include <time.h>#include "list.h"PLIST InitList(PLIST ptList){ ptList->ptrNodeHead = NULL; ptList->ptrNodeEnd = NULL; ptList->iSize = 0; return ptList;}_PLISTNODE InsertNode(_PLISTNODE ptInsertBack, _VALUE_ *pToInsert){_PLISTNODE ptNew; if (NULL == ptInsertBack){ return NULL; } ptNew = (_PLISTNODE)malloc(sizeof(_LISTNODE)); ptNew->prevPtr = ptInsertBack; ptNew->nextPtr = ptInsertBack->nextPtr; ptNew->tData.pvData = malloc(pToInsert->udwLength); memcpy(ptNew->tData.pvData, pToInsert->pvData, pToInsert->udwLength); ptNew->tData.udwLength = pToInsert->udwLength; ptInsertBack->nextPtr = ptNew; if (NULL != ptNew->nextPtr){ ptNew->nextPtr->prevPtr = ptNew; } return ptNew;}_PLISTNODE InsertPos(PLIST ptList, unsigned long udwPos, _VALUE_ *pToInsert){_PLISTNODE ptrNew;_ASSERT_RET(ptList != NULL, NULL);if (-1 == udwPos){ptList->ptrNodeHead = (_PLISTNODE)malloc(sizeof(_LISTNODE));ptList->ptrNodeEnd = ptList->ptrNodeHead;++ptList->iSize;ptList->ptrNodeHead->nextPtr = NULL;ptList->ptrNodeHead->prevPtr = NULL;ptList->ptrNodeHead->tData.pvData = malloc(pToInsert->udwLength);memcpy(ptList->ptrNodeHead->tData.pvData, pToInsert->pvData, pToInsert->udwLength);ptList->ptrNodeHead->tData.udwLength = pToInsert->udwLength;return ptList->ptrNodeHead;} _ASSERT_RET(udwPos < ptList->iSize, NULL); if (udwPos * 2 >= ptList->iSize || (0 == udwPos && 1 == ptList->iSize)){ unsigned long udwrPos = ptList->iSize - udwPos - 1; _PLISTNODE ptrNode = ptList->ptrNodeEnd; unsigned long udwDes = 0; for (; ptrNode != NULL; ptrNode = ptrNode->prevPtr){ if (udwDes++ == udwrPos){ ptrNew = InsertNode(ptrNode, pToInsert); if (ptList->iSize - 1 == udwPos){ ptList->ptrNodeEnd = ptrNew; } ++ptList->iSize; } } }else{ _PLISTNODE ptrNode = ptList->ptrNodeHead; unsigned long udwDes = 0; for (; ptrNode != NULL; ptrNode = ptrNode->nextPtr){ if (udwDes++ == udwPos){ ptrNew = InsertNode(ptrNode, pToInsert); ++ptList->iSize; } } }return ptrNew;}_PLISTNODE DeleteNode(_PLISTNODE ptToDelete){ _PLISTNODE toRet; ptToDelete->prevPtr->nextPtr = ptToDelete->nextPtr; ptToDelete->nextPtr->prevPtr = ptToDelete->prevPtr; toRet = ptToDelete->nextPtr; free(ptToDelete->tData.pvData); free(ptToDelete); return toRet;}_PLISTNODE FindNode(PLIST ptList, _VALUE_ *ptToFind){ _PLISTNODE ptFirst = ptList->ptrNodeHead; for (; ptFirst != NULL; ptFirst = ptFirst->nextPtr){ if (ptFirst->tData.udwLength == ptToFind->udwLength && !memcmp(ptFirst->tData.pvData, ptToFind->pvData, ptToFind->udwLength)){ return ptFirst; } } return NULL;}void For_each(PLIST ptNode, void (*DoSome)(_VALUE_ *pvalue)){ _PLISTNODE ptFirst = ptNode->ptrNodeHead; for (; ptFirst != NULL; ptFirst = ptFirst->nextPtr){ DoSome(&ptFirst->tData); }}PLIST SortList(PLIST ptList, int(*compare)(_VALUE_ *LeftValPtr, _VALUE_ *RightValPtr)){ _PLISTNODE ptEnd = ptList->ptrNodeEnd; _PLISTNODE ptCurEnd = ptEnd; _PLISTNODE ptTemp1 = ptList->ptrNodeHead, ptTemp2; for (; ptTemp1 != ptEnd; ptTemp1 = ptTemp1->nextPtr){ for (ptTemp2 = ptList->ptrNodeHead; ptTemp2 != ptCurEnd; ptTemp2 = ptTemp2->nextPtr){ if (compare(&ptTemp2->tData, &ptTemp2->nextPtr->tData)){ _VALUE_ vaTmp;memcpy(&vaTmp, &ptTemp2->tData, sizeof(_VALUE_)); memcpy(&ptTemp2->tData, &ptTemp2->nextPtr->tData, sizeof(_VALUE_)); memcpy(&ptTemp2->nextPtr->tData, &vaTmp, sizeof(_VALUE_)); } } ptCurEnd = ptCurEnd->prevPtr; } return ptList;}void ReleaseAll(PLIST ptrList){ _PLISTNODE ptTemp; _PLISTNODE ptFirst = ptrList->ptrNodeHead; for (; ptFirst != NULL; ){ ptTemp = ptFirst->nextPtr; free(ptFirst->tData.pvData); free(ptFirst); ptFirst = ptTemp; }}int Greater(_VALUE_ *LeftValPtr, _VALUE_ *RightValPtr){ return (int)(*(long*)LeftValPtr->pvData > *(long*)RightValPtr->pvData);}void Print(_VALUE_ *pvalue){ printf("%d ", *(long*)(pvalue->pvData));}int main(){LISTlist;longdwVa= 0;longc= -1;_PLISTNODEptNode;_VALUE_value;InitList(&list); srand((unsigned int)time(NULL));value.udwLength = sizeof(dwVa); for (; c != 20; ++c){ dwVa = rand()%10;value.pvData = &dwVa; InsertPos(&list, c, &value); } For_each(&list, Print); printf("/n"); SortList(&list, Greater); For_each(&list, Print);printf("/n");dwVa = 19;value.pvData = &dwVa;_PLISTNODE ptFind = FindNode(&list, &value);if (NULL != ptFind){ printf("%d/n", *(long*)(ptFind->tData.pvData)); } else { printf("can not find: %d/n", dwVa); } ReleaseAll(&list);system("pause"); return 0;}

 

 

开发环境为dev-cpp，这个双向链表可以存储任意长度的数据，算是自己对基本功的练习吧。。。