数据结构作业的代码——————栈的顺序实现

﹏ヽ暗。殇╰゛Y 2022-05-09 11:12 264阅读 0赞

作业code1:

  • 将上课给的顺序表形式实现栈的程序补充（代码已发给大家）：
  • 实现通过键盘进行插入
  • 实现通过键盘进行删除
  • 良好的人机交互

发的代码：

  1. #include <stdio.h>
  2. #include <malloc.h>
  4. typedef int SElemType;
  5. typedef int Status;
  6. #define INIT_SIZE 100
  7. #define STACKINCREMENT 10
  8. #define Ok 1
  9. #define Error 0
  10. #define True 1
  11. #define False 0
  12. typedef struct
  13. {
  15.     SElemType *base;
  16.     SElemType *top;
  17.     int stacksize;
  18. } SqStack;
  20. //初始化栈
  21. Status InitStack(SqStack *s)
  22. {
  24.     s->base = (SElemType *)malloc(INIT_SIZE * sizeof(SElemType));
  25.     if(!s->base)
  26.     {
  28.         puts("存储空间分配失败！");
  29.         return Error;
  30.     }
  31.     s->top = s->base;
  32.     s->stacksize = INIT_SIZE;
  33.     return Ok;
  34. }
  36. //清空栈
  37. Status ClearStack(SqStack *s)
  38. {
  40.     s->top = s->base;
  41.     return Ok;
  42. }
  44. //栈是否为空
  45. Status StackEmpty(SqStack *s)
  46. {
  48.     if(s->top == s->base)
  49.         return True;
  50.     else
  51.         return False;
  52. }
  54. //销毁栈
  55. Status Destroy(SqStack *s)
  56. {
  58.     free(s->base);
  59.     s->base = NULL;
  60.     s->top = NULL;
  61.     s->stacksize=0;
  62.     return Ok;
  63. }
  65. //获得栈顶元素
  66. Status GetTop(SqStack *s, SElemType &e)
  67. {
  69.     if(s->top == s->base)
  70.         return Error;
  71.     e = *(s->top - 1);
  72.     return Ok;
  73. }
  75. //压栈
  76. Status Push(SqStack *s, SElemType e)
  77. {
  79.     if(s->top - s->base >= s->stacksize)//栈满
  80.     {
  82.         s->base = (SElemType *)realloc(s->base, (s->stacksize + STACKINCREMENT) * sizeof(SElemType));
  83.         if(!s->base)
  84.         {
  86.             puts("存储空间分配失败！");
  87.             return Error;
  88.         }
  89.         s->top = s->base + s->stacksize;//修改栈顶位置
  90.         s->stacksize += STACKINCREMENT;//修改栈长度
  92.     }
  93.     *s->top++ = e;
  94.     return Ok;
  95. }
  97. //弹栈
  98. Status Pop(SqStack *s, SElemType *e)
  99. {
  101.     if(s->top == s->base)
  102.         return Error;
  103.     --s->top;
  104.     *e = *(s->top);
  105.     return Ok;
  106. }
  108. //遍历栈
  109. Status StackTraverse(SqStack *s,Status(*visit)(SElemType))
  110. {
  112.     SElemType *b = s->base;//此处不能直接用base或top移动，即不能改变原栈的结构
  113.     SElemType *t = s->top;
  114.     while(t > b)
  115.         visit(*b++);
  116.     printf("\n");
  117.     return Ok;
  118. }
  120. Status visit(SElemType c)
  121. {
  123.     printf("%d ",c);
  124.     return Ok;
  125. }
  127. int main()
  128. {
  130.     SqStack a;
  131.     SqStack *s = &a;
  132.     SElemType e;
  133.     InitStack(s);
  134.     int n;
  135.     puts("请输入要进栈的个数：");
  136.     scanf("%d", &n);
  137.     while(n--)
  138.     {
  140.         int m;
  141.         scanf("%d", &m);
  142.         Push(s, m);
  143.     }
  144.     StackTraverse(s, visit);
  145.     puts("");
  146.     puts("8进栈后：");
  147.     Push(s, 8);
  148.     StackTraverse(s, visit);
  149.     puts("");
  150.     Pop(s, &e);
  151.     printf("出栈的元素是：%d\n", e);
  152.     printf("元素出栈后事实上并没有清除，依然存在于内存空间，所谓的出栈只是指针移动，出栈的元素是%d\n", *s->top);//判断出栈后元素是否还存在于内存中
  153.     Destroy(s);
  154.     return 0;
  155. }
  • J17-4-name-code-第二次-栈.cpp

感觉就是给它换了个衣服，函数基本上都没有发上变化
明天 还需要写栈的链式实现

  1. #include <stdio.h>
  2. #include <malloc.h>
  3. #include <iostream>
  4. using namespace std;
  5. typedef int SElemType;
  6. typedef int Status;
  7. #define INIT_SIZE 100
  8. #define STACKINCREMENT 10
  9. #define Ok 1
  10. #define Error 0
  11. #define True 1
  12. #define False 0
  13. typedef struct
  14. {
  16.     SElemType *base;
  17.     SElemType *top;
  18.     int stacksize;
  19. } SqStack;
  21. //初始化栈
  22. Status InitStack(SqStack *s)
  23. {
  25.     s->base = (SElemType *)malloc(INIT_SIZE * sizeof(SElemType));
  26.     if(!s->base)
  27.     {
  29.         puts("存储空间分配失败！");
  30.         return Error;
  31.     }
  32.     s->top = s->base;
  33.     s->stacksize = INIT_SIZE;
  34.     return Ok;
  35. }
  37. //清空栈
  38. Status ClearStack(SqStack *s)
  39. {
  41.     s->top = s->base;
  42.     return Ok;
  43. }
  45. //栈是否为空
  46. Status StackEmpty(SqStack *s)
  47. {
  49.     if(s->top == s->base)
  50.         return True;
  51.     else
  52.         return False;
  53. }
  55. //销毁栈
  56. Status Destroy(SqStack *s)
  57. {
  59.     free(s->base);
  60.     s->base = NULL;
  61.     s->top = NULL;
  62.     s->stacksize=0;
  63.     return Ok;
  64. }
  66. //获得栈顶元素
  67. Status GetTop(SqStack *s, SElemType &e)
  68. {
  70.     if(s->top == s->base)
  71.         return Error;
  72.     e = *(s->top - 1);
  73.     return Ok;
  74. }
  76. //压栈
  77. Status Push(SqStack *s, SElemType e)
  78. {
  80.     if(s->top - s->base >= s->stacksize)//栈满
  81.     {
  83.         s->base = (SElemType *)realloc(s->base, (s->stacksize + STACKINCREMENT) * sizeof(SElemType));
  84.         if(!s->base)
  85.         {
  87.             puts("存储空间分配失败！");
  88.             return Error;
  89.         }
  90.         s->top = s->base + s->stacksize;//修改栈顶位置
  91.         s->stacksize += STACKINCREMENT;//修改栈长度
  93.     }
  94.     *s->top++ = e;
  95.     return Ok;
  96. }
  98. //弹栈
  99. Status Pop(SqStack *s, SElemType *e)
  100. {
  102.     if(s->top == s->base)
  103.         return Error;
  104.     --s->top;
  105.     *e = *(s->top);
  106.     return Ok;
  107. }
  109. //遍历栈
  110. Status StackTraverse(SqStack *s,Status(*visit)(SElemType))
  111. {
  113.     SElemType *b = s->base;//此处不能直接用base或top移动，即不能改变原栈的结构
  114.     SElemType *t = s->top -1;
  115.     while(t >= b)
  116.         visit(*t--);
  117. //        visit(*b++);
  118.     printf("\n");
  119.     return Ok;
  120. }
  122. Status visit(SElemType c)
  123. {
  125.     printf("%d ",c);
  126.     return Ok;
  127. }
  128. void menu()
  129. {
  131.       cout<<" menu："<<endl;
  132.       cout<<"1.进栈"<<endl;
  133.       cout<<"2.出栈"<<endl;
  134.       cout<<"3.输出"<<endl;
  135.       cout<<"4.menu"<<endl;
  136.       cout<<"0.结束"<<endl;
  137. }
  138. void preface()
  139. {
  141.         printf("                               *********************************************\n"
  142.                "                               *                                           *\n"
  143.                "                               *    此程序的功能：                         *\n"
  144.                "                               *    将整数类型的数据进行栈的操作           *\n"
  145.                "                               *                                           *\n"
  146.                "                               *********************************************\n"
  147.                "\n\n"
  148.                );
  149. }
  150. int main()
  151. {
  153.         SqStack a;
  154.         SqStack *s = &a;
  155.         SElemType e;
  156.         InitStack(s);
  157.         preface();
  158.         menu();
  159.         int choose;
  160.         int x;
  161.         while(true)
  162.         {
  164.                 cout<<"\n请选择:";
  165.                 cin>>choose;
  166.                 int k=0;
  167.                 switch(choose)
  168.                 {
  170.                         case 1:
  171.                                 printf("请输出需要进栈的个数:");
  172.                                 cin>>x;
  173.                                 printf("请输入%d个元素:",x);
  174.                                 while(x--)
  175.                                 {
  177.                                         cin>>e;
  178.                                         Push(s,e);
  179.                                 }
  180. //                                printf("进栈成功！\n");
  181.                                 break;
  182.                         case 2:
  183.                                 Pop(s,&e);
  184.                                 printf("出栈的元素是:%d\n", e);
  185.                                 break;
  186.                         case 3:
  187.                                 StackTraverse(s, visit);
  188.                                 printf("栈已全部输出!\n");
  189.                                 break;
  190.                         case 4:
  191.                                 menu();
  192.                                 break;
  193.                         case 0:
  194.                                 k=1;
  195.                                 break;
  196.                         default:
  197.                                 printf("请重新输入！");
  198.                                 break;
  199.                 }
  200.                 if(k)   break;
  201.         }
  202.         Destroy(s);
  203.     return 0;
  204. }

发表评论

表情：
评论列表 （有 0 条评论，264人围观）

还没有评论，来说两句吧...

相关阅读