qidao123.com ToB IT社区-企服评测·应用市场»论坛 › 数据库 › Oracle › 2024.7.22 作业

2024.7.22 作业

[复制链接]
发表于 2026-2-19 14:35:04 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

×


1.将双向链表和循环链表自己实现一遍，至少要实现创建、增、删、改、查、烧毁工作

循环链表

looplinklist.h
  2. #ifndef LOOPLINKLIST_H
  3. #define LOOPLINKLIST_H
  5. #include <myhead.h>
  7. typedef int datatype;
  9. typedef struct Node
  10. {
  11.         union
  12.         {
  13.                 int len;
  14.                 datatype data;
  15.         };
  16.         struct Node *next;
  17. }Node,*NodePtr;
  19. //创建循环链表
  20. NodePtr list_create();
  22. //链表判空
  23. int list_empty(NodePtr L);
  25. //链表申请空间封装节点
  26. NodePtr apply_node(datatype e);
  28. //按位置进行查找
  29. NodePtr list_search_pos(NodePtr L,int pos);
  31. //链表尾插
  32. int list_insert_tail(NodePtr L,datatype e);
  34. //链表遍历
  35. int list_show(NodePtr L);
  37. //链表头删
  38. int list_delete_head(NodePtr L);
  40. //链表销毁
  41. void list_destroy(NodePtr L);
  43. //约瑟夫环
  44. void ysfh(NodePtr L,int m);
  46. #endif
复制代码
 looplinklist.c
  2. #include "looplinklist.h"
  4. //创建循环链表
  5. NodePtr list_create()
  6. {
  7.         NodePtr L=(NodePtr)malloc(sizeof(Node));
  8.         if( NULL==L )
  9.         {
  10.                 printf("创建失败\n");
  11.                 return NULL;
  12.         }
  14.         L->len = 0;
  15.         L->next = L;
  16.         printf("创建成功\n");
  17.         return L;
  18. }
  20. //链表判空
  21. int list_empty(NodePtr L)
  22. {
  23.         return L->next==L;
  24. }
  26. //链表申请空间封装节点
  27. NodePtr apply_node(datatype e)
  28. {
  29.         NodePtr p = (NodePtr)malloc(sizeof(Node));
  30.         if( NULL==p )
  31.         {
  32.                 printf("申请失败\n");
  33.                 return NULL;
  34.         }
  35.         p->data = e;
  36.         p->next = NULL;
  37.         return p;
  38. }
  40. //按位置进行查找
  41. NodePtr list_search_pos(NodePtr L,int pos)
  42. {
  43.         if( NULL==L || pos<0 || pos>L->len)
  44.         {
  45.                 printf("查找失败\n");
  46.                 return NULL;
  47.         }
  48.         NodePtr q = L;
  49.         for(int i=1;i<=pos;i++)
  50.         {
  51.                 q=q->next;
  52.         }
  53.         return q;
  54. }
  56. //链表尾插
  57. int list_insert_tail(NodePtr L,datatype e)
  58. {
  59.         if( NULL==L )
  60.         {
  61.                 printf("尾插失败\n");
  62.                 return -1;
  63.         }
  64.         NodePtr p = apply_node(e);
  65.         if( NULL==p )
  66.         {
  67.                 return -1;
  68.         }
  69.         NodePtr q = list_search_pos(L,L->len);
  70.         p->next = q->next;
  71.         q->next = p;
  72.         L->len++;
  73.         return 0;
  74. }
  76. //链表遍历
  77. int list_show(NodePtr L)
  78. {
  79.         if( NULL==L || list_empty(L) )
  80.         {
  81.                 printf("遍历失败\n");
  82.                 return -1;
  83.         }
  84.         NodePtr q = L->next;
  85.         while( q!=L )
  86.         {
  87.                 printf("%d\t",q->data);
  88.                 q = q->next;
  89.         }
  90.         printf("\n");
  91.         return 0;
  92. }
  94. //链表头删
  95. int list_delete_head(NodePtr L)
  96. {
  97.         if( NULL==L || list_empty(L) )
  98.         {
  99.                 printf("头删失败\n");
  100.                 return -1;
  101.         }
  102.         NodePtr q = L->next;
  103.         L->next = q->next;
  104.         L->len--;
  105.         free(q);
  106.         q=NULL;
  107.         return 0;
  108. }
  110. //链表销毁
  111. void list_destroy(NodePtr L)
  112. {
  113.         if( NULL==L )
  114.         {
  115.                 printf("销毁失败\n");
  116.                 return ;
  117.         }
  118.         while( !list_empty(L) )
  119.         {
  120.                 list_delete_head(L);
  121.         }
  122.         free(L);
  123.         L=NULL;
  124.         printf("销毁成功\n");
  125.         return;
  126. }
复制代码
双向链表 

doublelinklist.h
  2. #ifndef DOUBLELINKLIST_H
  3. #define DOUBLELINKLIST_H
  5. typedef char datatype;
  7. typedef struct Node
  8. {
  9.         union
  10.         {
  11.                 int len;
  12.                 datatype data;
  13.         }
  15.         struct Node *prio;
  16.         struct Node *next;
  17. }Node,*NodePtr;
  19. //创建双向链表
  20. NodePtr list_create();
  22. //链表判空
  23. int list_empty(NodePtr L);
  25. //申请节点封装数据
  26. NodePtr apply_node(datatype e);
  28. //链表头插
  29. int list_insert_head(NodePtr L,datatype e);
  31. //链表遍历
  32. int list_show(NodePtr L);
  34. //按位置查找返回节点
  35. NodePtr list_search_pos(NodePtr L,int pos);
  37. //链表任意位置删除
  38. int list_delete_pos(NodePtr L,int pos);
  40. //链表空间释放
  41. void list_destroy(NodePtr L);
  43. #endif
复制代码
doublelinklist.c
  2. #include "doublelinklist.h"
  4. //创建双向链表
  5. NodePtr list_create()
  6. {
  7.         NodePtr L = (NodePtr)malloc(sizeof(Node));
  8.         if( NULL==L )
  9.         {
  10.                 printf("创建失败\n");
  11.                 return NULL;
  12.         }
  14.         L->len = 0;
  15.         L->prio = NULL;
  16.         L->next = NULL;
  18.         printf("创建成功\n");
  19.         return L;
  20. }
  22. //链表判空
  23. int list_empty(NodePtr L)
  24. {
  25.         return L->next == NULL;
  26. }
  28. //申请节点封装数据
  29. NodePtr apply_node(datatype e)
  30. {
  31.         NodePtr p =(NodePtr)malloc(sizeof(Node));
  32.         if( NULL==p )
  33.         {
  34.                 printf("节点申请失败\n");
  35.                 return NULL;
  36.         }
  38.         p->data = e;
  39.         p->prio = NULL;
  40.         p->next =NULL;
  42.         return
  43. }
  45. //链表头插
  46. int list_insert_head(NodePtr L,datatype e)
  47. {
  48.         if( NULL==L )
  49.         {
  50.                 printf("头插失败\n");
  51.                 return -1;
  52.         }
  53.         NodePtr p = apply_node(e);
  54.         if( NULL==p )
  55.         {
  56.                 return -1;
  57.         }
  59.         if( list_empty(L) )
  60.         {
  61.                 p->prio = L;
  62.                 L-next = p;
  63.         }
  64.         else
  65.         {
  66.                 p->prio = L;
  67.                 p->next = L->next;
  68.                 L->next->prio = p;
  69.                 L-next = p;
  70.         }
  71.         L->len++;
  73.         return 0;
  74. }
  76. //链表遍历
  77. int list_show(NodePtr L)
  78. {
  79.         if( NULL==L || list_empty(L) )
  80.         {
  81.                 printf("遍历失败\n");
  82.                 return -1;
  83.         }
  84.         printf("当前数据为：");
  85.         NodePtr q = L->next;
  86.         while( q )
  87.         {
  88.                 printf("%c\t",q->data);
  89.                 q=q->next;
  90.         }
  91.         printf("\n");
  92.         return 0;
  93. }
  95. //按位置查找返回节点
  96. NodePtr list_search_pos(NodePtr L,int pos)
  97. {
  98.         if( NULL==L || list_empty(L) || pos<0 || pos>L->len )
  99.         {
  100.                 printf("查找失败\n");
  101.                 return NULL;
  102.         }
  103.         NodePtr q = L;
  104.         for(int i=1;i<=pos;i++)
  105.         {
  106.                 q = q->next;
  107.         }
  108.         return q;
  109. }
  111. //链表任意位置删除
  112. int list_delete_pos(NodePtr L,int pos)
  113. {
  114.         if( NULL==L || list_empty(L) || pos<1 || pos>L->len )
  115.         {
  116.                 printf("删除失败\n");
  117.                 return -1;
  118.         }
  120.         NodePtr q = list_search_pos(L,pos);
  121.         if( q->next==NULL )
  122.         {
  123.                 q->prio->next==NULL;
  124.         }
  125.         else
  126.         {
  127.                 q->prio->next = q->next;
  128.                 q->next->prio = q->prio;
  129.         }
  130.         free(q);
  131.         q=NULL;
  132.         L->len--;
  133.         return 0;
  134. }
  136. //链表空间释放
  137. void list_destroy(NodePtr L)
  138. {
  139.         if( NULL==L )
  140.         {
  141.                 printf("释放失败\n");
  142.                 return ;
  143.         }
  144.         while( !list_empty(L) )
  145.         {
  146.                 list_delete_pos(L,1);
  147.         }
  148.         free(L);
  149.         L=NULL;
  150.         printf("链表释放成功\n");
  151.         return ;
  152. }
复制代码
 
2.利用循环链表完成约瑟夫环标题
  2. //约瑟夫环
  3. void ysfh(NodePtr L,int m)
  4. {
  5.         NodePtr p = L->next;
  6.         NodePtr q = L;
  7.         while( p->next!=p )
  8.         {
  9.                 for(int i=1;i<m;i++)
  10.                 {
  11.                         q = p;
  12.                         p = p->next;
  13.                         if(p==L)
  14.                         {
  15.                                 q=q->next;
  16.                                 p=p->next;
  17.                         }
  18.                 }
  19.                 printf("%d\t",p->data);
  20.                 NodePtr a = p;           //标记
  21.                     q->next = p->next;   //p->next 孤立
  22.                 p=p->next;
  23.                     free(a);                   //释放
  24.                     a = NULL;
  25.         }
  26.             printf("\n最后剩下的节点: %d\n", p->data);  
  27.             free(p); // 释放最后一节点  
  29. }
复制代码
3.利用栈，完成进制转换

输入：一个整数，进制数
输出：该数的对应的进制数
  2. void DC(StackPtr S,int m,int n)
  3. {
  4.         while(m/n!=0)
  5.         {
  6.                 S->top++;
  7.                 S->data[S->top]=m%n;
  8.                 m=m/n;
  9.         }
  10.         S->top++;
  11.         S->data[S->top]=1;
  12.         while(S->top!=-1)
  13.         {
  14.                 printf("%d",S->data[S->top]);
  15.                 S->top--;
  16.         }
  17.         printf("\n");
  18. }
复制代码
头脑导图
回复

使用道具 举报

返回列表

万万哇
+ 我要发帖

登录后关闭弹窗

登录参与点评抽奖  加入IT实名职场社区
去登录
快速回复 返回顶部 返回列表