7种数据结构

慢吞云雾缓吐愁  金牌会员 | 2025-3-19 17:16:15 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 987|帖子 987|积分 2961

次序表

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企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

慢吞云雾缓吐愁

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表