设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 技术交流 › C\C++交流 › 《带你学C带你飞》（语法篇） › S1E48：内存池
返回列表 发新帖
查看: 4667|回复: 8

[知识点备忘] S1E48：内存池

[复制链接]
小甲鱼
发表于 2017-4-19 02:50:22 | 显示全部楼层 |阅读模式
购买主题 已有 2 人购买  本主题需向作者支付 5 鱼币 才能浏览
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复

使用道具 举报

jetting
发表于 2020-3-4 11:55:23 | 显示全部楼层
通讯录程序（未加入内存池），看视频纯手打
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>

  5. struct Person
  6. {
  7.         char name[40];
  8.         char phone[20];
  9.         struct Person *next;
  10. };

  12. void getInput(struct Person *person);
  13. void printPerson(struct Person *person);
  14. void addPerson(struct Person **contacts);
  15. void changePerson(struct Person *contacts);
  16. void delPerson(struct Person **contacts);
  17. struct Person *findPerson(struct Person *contacts);
  18. void displayContacts(struct Person *contacts);
  19. void releaseContacts(struct Person **contacts);

  21. void getInput(struct Person *person)
  22. {
  23.         printf("请输入姓名：");
  24.         scanf("%s", person->name);
  25.         printf("请输入电话号码：");
  26.         scanf("%s", person->phone);
  27. }

  29. void addPerson(struct Person **contacts)
  30. {
  31.         struct Person *person;
  32.         struct Person *temp;
  33.        
  34.         person = (struct Person *)malloc(sizeof(struct Person));
  35.         if (person == NULL)
  36.         {
  37.                 printf("内存分配失败！\n");
  38.                 exit(1);
  39.         }
  40.        
  41.         getInput(person);
  42.        
  43.         // 将person用头插法添加到通讯录中
  44.         if (*contacts != NULL)
  45.         {
  46.                 temp = *contacts;
  47.                 *contacts = person;
  48.                 person->next = temp;
  49.         }
  50.         else
  51.         {
  52.                 *contacts = person;
  53.                 person->next = NULL;
  54.         }
  55. }

  57. void printPerson(struct Person *person)
  58. {
  59.         printf("联系人：%s\n", person->name);
  60.         printf("电话：%s\n", person->phone);
  61. }

  63. struct Person *findPerson(struct Person *contacts)
  64. {
  65.         struct Person *current;
  66.         char input[40];
  67.        
  68.         printf("请输入联系人：");
  69.         scanf("%s", input);
  70.        
  71.         current = contacts;
  72.         while (current != NULL && strcmp(current->name, input))
  73.         {
  74.                 current = current->next;
  75.         }
  76.        
  77.         return current;
  78. }

  80. void changePerson(struct Person *contacts)
  81. {
  82.         struct Person *person;
  83.        
  84.         person = findPerson(contacts);
  85.         if (person == NULL)
  86.         {
  87.                 printf("找不到该联系人！\n");
  88.         }
  89.         else
  90.         {
  91.                 printf("请输入新的联系电话：");
  92.                 scanf("%s", person->phone);
  93.         }
  94. }

  96. void delPerson(struct Person **contacts)
  97. {
  98. //        struct Person *temp;
  99.         struct Person *person;
  100.         struct Person *current;
  101.         struct Person *previous;
  102.        
  103.         // 先找到待删除的节点指针
  104.         person = findPerson(*contacts);
  105.         if (person == NULL)
  106.         {
  107.                 printf("找不到该联系人！\n");
  108.         }
  109.         else
  110.         {
  111.                 current = *contacts;
  112.                 previous = NULL;
  113.                
  114.                 // current定位到待删除的节点
  115.                 while (current != NULL && current != person)
  116.                 {
  117.                         previous = current;
  118.                         current = current->next;
  119.                 }
  120.                
  121.                 if (previous == NULL)
  122.                 {
  123.                         // 待删除的节点是第一个节点
  124.                         *contacts = current->next;
  125.                 }
  126.                 else
  127.                 {
  128.                         // 待删除的节点不是第一个节点
  129.                         previous->next = current->next;
  130.                 }
  131.                
  132.                 free(person);
  133.         }
  134. }

  136. void displayContacts(struct Person *contacts)
  137. {
  138.         struct Person *current;
  139.        
  140.         current = contacts;
  141.         while (current != NULL)
  142.         {
  143.                 printPerson(current);
  144.                 current = current->next;
  145.         }
  146. }

  148. void releaseContacts(struct Person **contacts)
  149. {
  150.         struct Person *temp;
  151.        
  152.         while (*contacts != NULL)
  153.         {
  154.                 temp = *contacts;
  155.                 *contacts = (*contacts)->next;
  156.                 free(temp);
  157.         }
  158. }

  160. int main(void)
  161. {
  162.         int code;
  163.         struct Person *contacts = NULL;
  164.         struct Person *person;
  165.        
  166.         printf("| 欢迎使用通讯录管理程序 |\n");
  167.         printf("|--- 1:插入新的联系人 ---|\n");
  168.         printf("|--- 2:查找已有联系人 ---|\n");
  169.         printf("|--- 3:更改已有联系人 ---|\n");
  170.         printf("|--- 4:删除已有联系人 ---|\n");
  171.         printf("|--- 5:显示当前通讯录 ---|\n");
  172.         printf("|--- 6:退出通讯录程序 ---|\n");
  173.         printf("|- Powered by FishC.com -|\n");
  174.        
  175.         while (1)
  176.         {
  177.                 printf("\n请输入指令代码：");
  178.                 scanf("%d", &code);
  179.                 switch (code)
  180.                 {
  181.                         case 1: addPerson(&contacts); break;
  182.                        
  183.                         case 2: person = findPerson(contacts);
  184.                                         if (person == NULL)
  185.                                         {
  186.                                                 printf("找不到联系人！\n");
  187.                                         }
  188.                                         else
  189.                                         {
  190.                                                 printPerson(person);
  191.                                         }
  192.                                         break;
  193.                        
  194.                         case 3: changePerson(contacts); break;
  195.                        
  196.                         case 4: delPerson(&contacts); break;
  197.                        
  198.                         case 5: displayContacts(contacts); break;
  199.                        
  200.                         case 6: goto END;
  201.                 }
  202.         }
  203.        
  204. END:
  205.         releaseContacts(&contacts);
  206.        
  207.         return 0;
  208. }
复制代码
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 6 反对 1

使用道具 举报

jetting
发表于 2020-3-4 11:56:20 | 显示全部楼层
通讯录程序（加入内存池），看视频纯手打
  1. // 加入内存池的版本
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>

  6. #define MAX 1024        //定义内存池最大空间

  8. struct Person
  9. {
  10.         char name[40];
  11.         char phone[20];
  12.         struct Person *next;
  13. };

  15. struct Person *pool = NULL;
  16. int count;

  18. void getInput(struct Person *person);
  19. void printPerson(struct Person *person);
  20. void addPerson(struct Person **contacts);
  21. void changePerson(struct Person *contacts);
  22. void delPerson(struct Person **contacts);
  23. struct Person *findPerson(struct Person *contacts);
  24. void displayContacts(struct Person *contacts);
  25. void releaseContacts(struct Person **contacts);
  26. void releasePool(void);

  28. void getInput(struct Person *person)
  29. {
  30.         printf("请输入姓名：");
  31.         scanf("%s", person->name);
  32.         printf("请输入电话号码：");
  33.         scanf("%s", person->phone);
  34. }

  36. void addPerson(struct Person **contacts)
  37. {
  38.         struct Person *person;
  39.         struct Person *temp;
  40.        
  41.         // 如果内存池非空，则直接从里面获取空间
  42.         if (pool != NULL)
  43.         {
  44.                 person = pool;
  45.                 pool = pool->next;
  46.                 count--;
  47.         }
  48.         // 如果内存池为空，则调用malloc函数申请新的内存空间
  49.         else
  50.         {
  51.                 person = (struct Person *)malloc(sizeof(struct Person));
  52.                 if (person == NULL)
  53.                 {
  54.                         printf("内存分配失败！\n");
  55.                         exit(1);
  56.                 }
  57.         }

  59.         getInput(person);
  60.        
  61.         // 将person用头插法添加到通讯录中
  62.         if (*contacts != NULL)
  63.         {
  64.                 temp = *contacts;
  65.                 *contacts = person;
  66.                 person->next = temp;
  67.         }
  68.         else
  69.         {
  70.                 *contacts = person;
  71.                 person->next = NULL;
  72.         }
  73. }

  75. void printPerson(struct Person *person)
  76. {
  77.         printf("联系人：%s\n", person->name);
  78.         printf("电话：%s\n", person->phone);
  79. }

  81. struct Person *findPerson(struct Person *contacts)
  82. {
  83.         struct Person *current;
  84.         char input[40];
  85.        
  86.         printf("请输入联系人：");
  87.         scanf("%s", input);
  88.        
  89.         current = contacts;
  90.         while (current != NULL && strcmp(current->name, input))
  91.         {
  92.                 current = current->next;
  93.         }
  94.        
  95.         return current;
  96. }

  98. void changePerson(struct Person *contacts)
  99. {
  100.         struct Person *person;
  101.        
  102.         person = findPerson(contacts);
  103.         if (person == NULL)
  104.         {
  105.                 printf("找不到该联系人！\n");
  106.         }
  107.         else
  108.         {
  109.                 printf("请输入新的联系电话：");
  110.                 scanf("%s", person->phone);
  111.         }
  112. }

  114. void delPerson(struct Person **contacts)
  115. {
  116.         struct Person *temp;
  117.         struct Person *person;
  118.         struct Person *current;
  119.         struct Person *previous;
  120.        
  121.         // 先找到待删除的节点指针
  122.         person = findPerson(*contacts);
  123.         if (person == NULL)
  124.         {
  125.                 printf("找不到该联系人！\n");
  126.         }
  127.         else
  128.         {
  129.                 current = *contacts;
  130.                 previous = NULL;
  131.                
  132.                 // current定位到待删除的节点
  133.                 while (current != NULL && current != person)
  134.                 {
  135.                         previous = current;
  136.                         current = current->next;
  137.                 }
  138.                
  139.                 if (previous == NULL)
  140.                 {
  141.                         // 待删除的节点是第一个节点
  142.                         *contacts = current->next;
  143.                 }
  144.                 else
  145.                 {
  146.                         // 待删除的节点不是第一个节点
  147.                         previous->next = current->next;
  148.                 }
  149.                
  150.                 // 判断内存池是不是有空位
  151.                 if (count < MAX)
  152.                 {
  153.                         if (pool != NULL)
  154.                         {
  155.                                 temp = pool;
  156.                                 pool = person;
  157.                                 person->next = temp;
  158.                         }
  159.                         else
  160.                         {
  161.                                 pool = person;
  162.                                 person->next = NULL;
  163.                         }
  164.                         count++;
  165.                 }
  166.                 else
  167.                 {
  168.                         free(person);
  169.                 }
  170.                
  171.         }
  172. }

  174. void displayContacts(struct Person *contacts)
  175. {
  176.         struct Person *current;
  177.        
  178.         current = contacts;
  179.         while (current != NULL)
  180.         {
  181.                 printPerson(current);
  182.                 current = current->next;
  183.         }
  184. }

  186. void releaseContacts(struct Person **contacts)
  187. {
  188.         struct Person *temp;
  189.        
  190.         while (*contacts != NULL)
  191.         {
  192.                 temp = *contacts;
  193.                 *contacts = (*contacts)->next;
  194.                 free(temp);
  195.         }
  196. }

  198. void releasePool(void)
  199. {
  200.         struct Person *temp;
  201.        
  202.         while (pool != NULL)
  203.         {
  204.                 temp = pool;
  205.                 pool = pool->next;
  206.                 free(temp);
  207.         }
  208. }

  210. int main(void)
  211. {
  212.         int code;
  213.         struct Person *contacts = NULL;
  214.         struct Person *person;
  215.        
  216.         printf("| 欢迎使用通讯录管理程序 |\n");
  217.         printf("|--- 1:插入新的联系人 ---|\n");
  218.         printf("|--- 2:查找已有联系人 ---|\n");
  219.         printf("|--- 3:更改已有联系人 ---|\n");
  220.         printf("|--- 4:删除已有联系人 ---|\n");
  221.         printf("|--- 5:显示当前通讯录 ---|\n");
  222.         printf("|--- 6:退出通讯录程序 ---|\n");
  223.         printf("|- Powered by FishC.com -|\n");
  224.        
  225.         while (1)
  226.         {
  227.                 printf("\n请输入指令代码：");
  228.                 scanf("%d", &code);
  229.                 switch (code)
  230.                 {
  231.                         case 1: addPerson(&contacts); break;
  232.                        
  233.                         case 2: person = findPerson(contacts);
  234.                                         if (person == NULL)
  235.                                         {
  236.                                                 printf("找不到联系人！\n");
  237.                                         }
  238.                                         else
  239.                                         {
  240.                                                 printPerson(person);
  241.                                         }
  242.                                         break;
  243.                        
  244.                         case 3: changePerson(contacts); break;
  245.                        
  246.                         case 4: delPerson(&contacts); break;
  247.                        
  248.                         case 5: displayContacts(contacts); break;
  249.                        
  250.                         case 6: goto END;
  251.                 }
  252.         }
  253.        
  254. END:
  255.         releaseContacts(&contacts);
  256.         releasePool();
  257.         return 0;
  258. }
复制代码
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 4 反对 0

使用道具 举报

pinapple
发表于 2020-3-7 21:58:21 | 显示全部楼层
千万不要再while()后面打上；
不要问我为什么
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

weishen
发表于 2020-4-8 13:04:41 | 显示全部楼层
漂亮
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复

使用道具 举报

1241702927
发表于 2020-5-7 16:47:32 | 显示全部楼层
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>

  5. struct Person   //单链表节点
  6. {
  7.         char name[128];
  8.         char phonenum[128];
  9.         struct Person *next;
  10. };

  12. int sum = 0;     //联系人总数
  13. void star(); //程序开场白
  14. void addPerson(struct Person **head);  //1.头插法插入联系人
  15. void add1Person(struct Person **head);  //1.尾插法插入联系人,头、尾插法在main函数中更换即可
  16. void getPerson(struct Person *person);  //1.1录入联系人
  17. int displayContacts(struct Person *head,int count);   //5.显示当前通讯录
  18. void release(struct Person *head);   //6.退出通讯录程序
  19. void findPerson(struct Person *head);  //2.查找已有联系人
  20. void changePerson(struct Person *head);  //3.更改已有联系人
  21. void delPerson(struct Person **head);   //4.删除已有联系人

  23. int main(void)
  24. {
  25.         struct Person *head = NULL;  // 单3链表 头指针
  26.         int num;

  28.         star();  
  29.         
  30.         do
  31.         {
  32.                 do
  33.                 {
  34.                         num = 0;
  35.                         printf("\n*请输入功能选项：");
  36.                         scanf("%d",&num);
  37.                         fflush(stdin);
  38.                         if(num >= 1 && num <= 6)
  39.                         {
  40.                                 break;
  41.                         }
  42.                         printf("无效指令，请重新输入！\n");
  43.                 }while(1);
  44.                 switch(num)
  45.                 {
  46.                         case 1: add1Person(&head);break;
  47.                         case 2: findPerson(head);break;
  48.                         case 3: changePerson(head);break;
  49.                         case 4: delPerson(&head);break;
  50.                         case 5: displayContacts(head,0);break;
  51.                         case 6: release(head);break;
  52.                 }
  53.         }while(num != 6);

  55.         return 0;
  56. }

  58. void delPerson(struct Person **head)  //4.删除已有联系人
  59. {
  60.         struct Person *now;
  61.         struct Person *before = NULL;
  62.         int num,count = 1,num1;

  64.         now = *head;

  66.         num1 = displayContacts(*head,4);

  68.         if(num1 != 1)
  69.         {
  70.                 do
  71.                 {
  72.                         printf("请输入要删除的联系人序号(1~%d)：",sum);
  73.                         scanf("%d",&num);
  74.                         fflush(stdin);
  75.                         if(num <= sum && num >= 1)
  76.                         {
  77.                                 break;
  78.                         }
  79.                         printf("序号输出错误，请重新输入！\n");
  80.                 }while(1);

  82.                 while(count < num && now != NULL)
  83.                 {
  84.                         before = now;
  85.                         now = now->next;
  86.             count++;
  87.                 }

  89.                 if(before == NULL)
  90.                 {
  91.                         *head  = now->next;
  92.                 }
  93.                 else
  94.                 {
  95.                         before->next = now->next;
  96.                 }
  97.                 free(now);
  98.                 sum--;

  100.                 printf("\n*联系人信息删除完成！\n");
  101.         }

  103. }

  105. void changePerson(struct Person *head)  //3.更改已有联系人
  106. {
  107.         struct Person *person;
  108.         int num1 = 0,num,count = 1;
  109.     char ch;   //判读是否更改姓名、电话

  111.         person = head;
  112.         num1 = displayContacts(head,3);

  114.         if(num1 != 1)
  115.         {
  116.                 do
  117.                 {
  118.                         printf("请输入要更改的联系人序号(1~%d)：",sum);
  119.                         scanf("%d",&num);
  120.                         fflush(stdin);
  121.                         if(num <= sum && num >= 1)
  122.                         {
  123.                                 break;
  124.                         }
  125.                         printf("序号输出错误，请重新输入！\n");
  126.                 }while(1);

  128.                 while(person != NULL && count < num)
  129.                 {
  130.                         person = person->next;
  131.                         count++;
  132.                 }

  134.                 printf("\n*更改第%d位联系人信息：\n",num);
  135.                 printf("是否更改姓名“%s ”（Y/N)？",person->name);
  136.         scanf("%c",&ch);
  137.         fflush(stdin);
  138.         if(ch == 'Y')
  139.         {
  140.             printf("更改为：");
  141.                         scanf("%s",person->name);
  142.                         fflush(stdin);
  143.                 }
  144.                 printf("是否更改电话“%s ”（Y/N)？",person->phonenum);
  145.         scanf("%c",&ch);
  146.         fflush(stdin);
  147.         if(ch == 'Y')
  148.         {
  149.             printf("更改为：");
  150.                         scanf("%s",person->phonenum);
  151.                         fflush(stdin);
  152.                 }
  153.                 printf("\n*联系人信息更改完成！\n");
  154.         }
  155.         else
  156.         {
  157.                 return;
  158.         }
  159. }

  161. void findPerson(struct Person *head)   //2.查找已有联系人
  162. {
  163.         char find[128];
  164.         int num = 0;
  165.         struct Person *person;

  167.         printf("请输入查找信息（姓名/电话）：");
  168.         scanf("%s",find);
  169.         getchar();

  171.         person = head;
  172.         while(person != NULL)
  173.         {
  174.                 if(!strcmp(person->name,find) || !strcmp(person->phonenum,find))
  175.                 {
  176.                     if(num == 0)
  177.                         {
  178.                                 printf("\n-------已查找到以下联系信息-------\n");
  179.                         }
  180.                         printf("\n第%d位联系人：\n",num + 1);
  181.                         printf("姓名：%s\n",person->name);
  182.                         printf("电话：%s\n",person->phonenum);
  183.                           num++;
  184.                 }
  185.                 person = person->next;
  186.         }
  187.         if(num == 0)
  188.         {
  189.                 printf("\n--------未查到相关联系信息--------\n");
  190.         }
  191.         printf("\n----------------------------------\n");

  193. }
  194. void release(struct Person *head)  //6.退出通讯录程序
  195. {
  196.         printf("\n*此通讯录小程序已退出!\n");
  197.         free(head);
  198.         exit(1);
  199. }

  201. int displayContacts(struct Person *head,int count)  //5.显示当前通讯录
  202. {
  203.     int num = 1;
  204.         struct Person *person;

  206.         person = head;

  208.     printf("------------通讯录如下------------\n");
  209.         while(person != NULL)
  210.         {
  211.                 printf("\n第%d位联系人信息如下：\n",num);
  212.                 printf("姓名：%s\n",person->name);
  213.                 printf("电话：%s\n",person->phonenum);
  214.                 num++;
  215.                 person = person->next;
  216.         }
  217.         if(num == 1)
  218.         {
  219.                 if(count == 0)
  220.                 {
  221.                         printf("\n当前通讯录暂无联系人，请添加后再显示！\n");
  222.                 }
  223.                 else if(count == 3)
  224.                 {
  225.                         printf("\n当前通讯录暂无联系人，请添加后再进行更改！\n");
  226.                 }
  227.                 else if(count == 4)
  228.                 {
  229.                         printf("\n当前通讯录暂无联系人，请添加后再进行删除！\n");
  230.                 }
  231.             printf("\n----------------------------------\n");
  232.                 return 1;
  233.         }
  234.         printf("\n----------------------------------\n");
  235.         num = 1;
  236. }

  238. void getPerson(struct Person *person)  //1.1录入联系人
  239. {
  240.         printf("\n请输入联系人姓名：");
  241.         scanf("%s",person->name);
  242.         getchar();
  243.         printf("请输入联系人电话：");
  244.         scanf("%s",person->phonenum);
  245.         getchar();
  246. }

  248. void addPerson(struct Person **head)  //1.头插法插入联系人
  249. {
  250.         struct Person *person;
  251.         struct Person *temp;

  253.         person = (struct Person *)malloc(sizeof(struct Person));
  254.         if(person == NULL)
  255.         {
  256.                 printf("内存分配失败！\n");
  257.                 exit(1);
  258.         }

  260.         getPerson(person);  //录入联系人

  262.         if(*head == NULL)
  263.         {
  264.                 *head = person;
  265.                 person->next = NULL;
  266.         }
  267.         else
  268.         {
  269.                 temp = *head;
  270.                 *head = person;
  271.                 person->next = temp;
  272.         }
  273.         printf("第%d位联系人已录入完成！\n",++sum);
  274. }

  276. void add1Person(struct Person **head)  //1.尾插法插入联系人
  277. {
  278.         struct Person *person;
  279.         static struct Person *tail;

  281.         person = (struct Person *)malloc(sizeof(struct Person));
  282.         if(person == NULL)
  283.         {
  284.                 printf("内存分配失败！\n");
  285.                 exit(1);
  286.         }

  288.         getPerson(person);  //录入联系人

  290.         if(*head == NULL)
  291.         {
  292.                 *head = person;
  293.                 person->next = NULL;
  294.         }
  295.         else
  296.         {
  297.                 tail->next = person;
  298.                 person->next = NULL;
  299.         }
  300.     tail = person;
  301.         printf("第%d位联系人已录入完成！\n",++sum);
  302. }

  304. void star()
  305. {
  306.         printf("********************************\n");
  307.         printf("**     夏日de通讯录小程序     **\n");
  308.         printf("**  功能选项：                **\n");
  309.         printf("**  1.添加新的联系人          **\n");
  310.         printf("**  2.查找已有联系人          **\n");
  311.         printf("**  3.更改已有联系人          **\n");
  312.         printf("**  4.删除已有联系人          **\n");
  313.         printf("**  5.显示当前通讯录          **\n");
  314.         printf("**  6.退出通讯录程序          **\n");
  315.         printf("**                            **\n");
  316.         printf("********************************\n");
  317. }
复制代码
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

1241702927
发表于 2020-5-7 21:26:28 | 显示全部楼层
有内存池版本，并对上一版本releasePerson函数中做了修正~
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>  //有内存池版本

  5. #define MAX 1024

  7. struct Person   //单链表节点
  8. {
  9.         char name[128];
  10.         char phonenum[128];
  11.         struct Person *next;
  12. };

  14. struct Person *pool = NULL;  //定义内存池

  16. int sum = 0;     //联系人总数
  17. void star(); //程序开场白
  18. void addPerson(struct Person **head);  //1.头插法插入联系人
  19. void add1Person(struct Person **head);  //1.尾插法插入联系人,头、尾插法在main函数中更换即可
  20. void getPerson(struct Person *person);  //1.1录入联系人
  21. int displayContacts(struct Person *head,int count);   //5.显示当前通讯录
  22. void release(struct Person **head);   //6.退出通讯录程序
  23. void findPerson(struct Person *head);  //2.查找已有联系人
  24. void changePerson(struct Person *head);  //3.更改已有联系人
  25. void delPerson(struct Person **head);   //4.删除已有联系人
  26. void releasepool(void);  //释放内存池

  28. int main(void)
  29. {
  30.         struct Person *head = NULL;  // 单链表 头指针
  31.         int num;

  33.         star();

  35.         do
  36.         {
  37.                 do
  38.                 {
  39.                         num = 0;
  40.                         printf("\n*请输入功能选项：");
  41.                         scanf("%d",&num);
  42.                         fflush(stdin);
  43.                         if(num >= 1 && num <= 6)
  44.                         {
  45.                                 break;
  46.                         }
  47.                         printf("无效指令，请重新输入！\n");
  48.                 }while(1);
  49.                 switch(num)
  50.                 {
  51.                         case 1: add1Person(&head);break;
  52.                         case 2: findPerson(head);break;
  53.                         case 3: changePerson(head);break;
  54.                         case 4: delPerson(&head);break;
  55.                         case 5: displayContacts(head,0);break;
  56.                         case 6: release(&head);break;
  57.                 }
  58.         }while(num != 6);

  60.         return 0;
  61. }

  63. void releasepool(void)   //释放内存池
  64. {
  65.         struct Person *temp;

  67.         while(pool != NULL)
  68.         {
  69.                 temp = pool;
  70.                 pool = pool->next;
  71.                 free(pool);
  72.         }
  73. }


  76. void delPerson(struct Person **head)  //4.删除已有联系人
  77. {
  78.         struct Person *now;
  79.         struct Person *before = NULL;
  80.         struct Person *temp;
  81.         int num,count = 1,num1;

  83.         now = *head;

  85.         num1 = displayContacts(*head,4);

  87.         if(num1 != 1)
  88.         {
  89.                 do
  90.                 {
  91.                         printf("请输入要删除的联系人序号(1~%d)：",sum);
  92.                         scanf("%d",&num);
  93.                         fflush(stdin);
  94.                         if(num <= sum && num >= 1)
  95.                         {
  96.                                 break;
  97.                         }
  98.                         printf("序号输出错误，请重新输入！\n");
  99.                 }while(1);

  101.                 while(count < num && now != NULL)
  102.                 {
  103.                         before = now;
  104.                         now = now->next;
  105.             count++;
  106.                 }

  108.                 if(before == NULL)
  109.                 {
  110.                         *head  = now->next;
  111.                 }
  112.                 else
  113.                 {
  114.                         before->next = now->next;
  115.                 }
  116.                 if(sum < MAX) //判断内存是否有空位
  117.                 {
  118.                         if(pool != NULL)
  119.                         {
  120.                                 temp = pool;
  121.                                 pool = now;
  122.                                 now->next = temp;
  123.                         }
  124.                         else
  125.                         {
  126.                                 pool = now;
  127.                                 now->next = NULL;
  128.                         }
  129.                 }
  130.                 else
  131.                 {
  132.                         free(now);
  133.                 }
  134.                 sum--;

  136.                 printf("\n*联系人信息删除完成！\n");
  137.         }

  139. }

  141. void changePerson(struct Person *head)  //3.更改已有联系人
  142. {
  143.         struct Person *person;
  144.         int num1 = 0,num,count = 1;
  145.     char ch;   //判读是否更改姓名、电话

  147.         person = head;
  148.         num1 = displayContacts(head,3);

  150.         if(num1 != 1)
  151.         {
  152.                 do
  153.                 {
  154.                         printf("请输入要更改的联系人序号(1~%d)：",sum);
  155.                         scanf("%d",&num);
  156.                         fflush(stdin);
  157.                         if(num <= sum && num >= 1)
  158.                         {
  159.                                 break;
  160.                         }
  161.                         printf("序号输出错误，请重新输入！\n");
  162.                 }while(1);

  164.                 while(person != NULL && count < num)
  165.                 {
  166.                         person = person->next;
  167.                         count++;
  168.                 }

  170.                 printf("\n*更改第%d位联系人信息：\n",num);
  171.                 printf("是否更改姓名“%s ”（Y/N)？",person->name);
  172.         scanf("%c",&ch);
  173.         fflush(stdin);
  174.         if(ch == 'Y')
  175.         {
  176.             printf("更改为：");
  177.                         scanf("%s",person->name);
  178.                         fflush(stdin);
  179.                 }
  180.                 printf("是否更改电话“%s ”（Y/N)？",person->phonenum);
  181.         scanf("%c",&ch);
  182.         fflush(stdin);
  183.         if(ch == 'Y')
  184.         {
  185.             printf("更改为：");
  186.                         scanf("%s",person->phonenum);
  187.                         fflush(stdin);
  188.                 }
  189.                 printf("\n*联系人信息更改完成！\n");
  190.         }
  191.         else
  192.         {
  193.                 return;
  194.         }
  195. }

  197. void findPerson(struct Person *head)   //2.查找已有联系人
  198. {
  199.         char find[128];
  200.         int num = 0;
  201.         struct Person *person;

  203.         printf("请输入查找信息（姓名/电话）：");
  204.         scanf("%s",find);
  205.         getchar();

  207.         person = head;
  208.         while(person != NULL)
  209.         {
  210.                 if(!strcmp(person->name,find) || !strcmp(person->phonenum,find))
  211.                 {
  212.                     if(num == 0)
  213.                         {
  214.                                 printf("\n-------已查找到以下联系信息-------\n");
  215.                         }
  216.                         printf("\n第%d位联系人：\n",num + 1);
  217.                         printf("姓名：%s\n",person->name);
  218.                         printf("电话：%s\n",person->phonenum);
  219.                           num++;
  220.                 }
  221.                 person = person->next;
  222.         }
  223.         if(num == 0)
  224.         {
  225.                 printf("\n--------未查到相关联系信息--------\n");
  226.         }
  227.         printf("\n----------------------------------\n");

  229. }
  230. void release(struct Person **head)  //6.退出通讯录程序
  231. {
  232.     struct Person *temp;
  233.    
  234.     while(*head != NULL)  //释放已存储的
  235.     {
  236.             temp = *head;
  237.             *head = (*head)->next;
  238.                 free(*head);
  239.         }

  241.         releasepool();  //释放内存池的

  243.         printf("\n*此通讯录小程序已退出!\n");
  244.         exit(1);
  245. }

  247. int displayContacts(struct Person *head,int count)  //5.显示当前通讯录
  248. {
  249.     int num = 1;
  250.         struct Person *person;

  252.         person = head;

  254.     printf("------------通讯录如下------------\n");
  255.         while(person != NULL)
  256.         {
  257.                 printf("\n第%d位联系人信息如下：\n",num);
  258.                 printf("姓名：%s\n",person->name);
  259.                 printf("电话：%s\n",person->phonenum);
  260.                 num++;
  261.                 person = person->next;
  262.         }
  263.         if(num == 1)
  264.         {
  265.                 if(count == 0)
  266.                 {
  267.                         printf("\n当前通讯录暂无联系人，请添加后再显示！\n");
  268.                 }
  269.                 else if(count == 3)
  270.                 {
  271.                         printf("\n当前通讯录暂无联系人，请添加后再进行更改！\n");
  272.                 }
  273.                 else if(count == 4)
  274.                 {
  275.                         printf("\n当前通讯录暂无联系人，请添加后再进行删除！\n");
  276.                 }
  277.             printf("\n----------------------------------\n");
  278.                 return 1;
  279.         }
  280.         printf("\n----------------------------------\n");
  281.         num = 1;
  282. }

  284. void getPerson(struct Person *person)  //1.1录入联系人
  285. {
  286.         printf("\n请输入联系人姓名：");
  287.         scanf("%s",person->name);
  288.         getchar();
  289.         printf("请输入联系人电话：");
  290.         scanf("%s",person->phonenum);
  291.         getchar();
  292. }

  294. void addPerson(struct Person **head)  //1.头插法插入联系人
  295. {
  296.         struct Person *person;
  297.         struct Person *temp;

  299.         if(pool != NULL)  //检测内存池是否有位置
  300.         {
  301.                 person = pool;
  302.                 pool = pool->next;
  303.         }
  304.         else
  305.         {
  306.                 person = (struct Person *)malloc(sizeof(struct Person));
  307.                 if(person == NULL)
  308.                 {
  309.                         printf("内存分配失败！\n");
  310.                         exit(1);
  311.                 }
  312.         }

  314.         getPerson(person);  //录入联系人

  316.         if(*head == NULL)
  317.         {
  318.                 *head = person;
  319.                 person->next = NULL;
  320.         }
  321.         else
  322.         {
  323.                 temp = *head;
  324.                 *head = person;
  325.                 person->next = temp;
  326.         }
  327.         printf("第%d位联系人已录入完成！\n",++sum);
  328. }

  330. void add1Person(struct Person **head)  //1.尾插法插入联系人
  331. {
  332.         struct Person *person;
  333.         static struct Person *tail;

  335.         if(pool != NULL)  //检测内存池是否有位置
  336.         {
  337.                 person = pool;
  338.                 pool = pool->next;
  339.         }
  340.         else
  341.         {
  342.                 person = (struct Person *)malloc(sizeof(struct Person));
  343.                 if(person == NULL)
  344.                 {
  345.                         printf("内存分配失败！\n");
  346.                         exit(1);
  347.                 }
  348.         }

  350.         getPerson(person);  //录入联系人

  352.         if(*head == NULL)
  353.         {
  354.                 *head = person;
  355.                 person->next = NULL;
  356.         }
  357.         else
  358.         {
  359.                 tail->next = person;
  360.                 person->next = NULL;
  361.         }
  362.     tail = person;
  363.         printf("第%d位联系人已录入完成！\n",++sum);
  364. }

  366. void star()
  367. {
  368.         printf("********************************\n");
  369.         printf("**     夏日de通讯录小程序     **\n");
  370.         printf("**  功能选项：                **\n");
  371.         printf("**  1.添加新的联系人          **\n");
  372.         printf("**  2.查找已有联系人          **\n");
  373.         printf("**  3.更改已有联系人          **\n");
  374.         printf("**  4.删除已有联系人          **\n");
  375.         printf("**  5.显示当前通讯录          **\n");
  376.         printf("**  6.退出通讯录程序          **\n");
  377.         printf("**                            **\n");
  378.         printf("********************************\n");
  379. }
复制代码
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

很酷1212
发表于 2022-3-22 15:08:42 | 显示全部楼层
看完了
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

Puppet16
发表于 2022-5-6 18:48:05 | 显示全部楼层
好好学习才能天天向上！求更新
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2024-4-27 08:57

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表