使用数组实现动态大小的堆栈，元素打印错误

3 回答

• 1

  这段代码中有些问题出了问题 .

  首先，Olafs评论正确格式化代码可能会显得苛刻，但这是合理的 . 根据您使用的编辑器，只需2次击键即可 . （例如Visual Studio中的CTRL-k-f） . 为了将代码放到SO上的问题，秘密是（再次在VS中）：CTRL-a（全部标记）TAB CTRL-C并且您需要源代码在此站点上显示为源代码所需的初始4个缩进 .

  其次，这些天没人会用-1初始化top . 真的，没有任何好处 . 通常，您将初始化为0.然后，如果 p->top == 0 ，则堆栈为空 . 堆栈已满，如果 p->maxSize == p->top . 并且堆栈上的最高值（如果不为空）是 p->a[p->top - 1] .

  接下来，您的 initstack() 函数应该是 p->a = malloc(maxSize * sizeof(int)); . 除非有特殊要求创建一个懒堆栈或诸如此类的东西 .

  您的显示函数堆栈参数按值传递（忘记'*'） .

  void display(struct stack *p) {
      if (NULL != p)
      {
          if (NULL != p->a)
          {
              for (int i = 0; i < p->top; i++)
              {
                  printf("%d\n", p->a[i]);
              }
          }
      }
  }
  

  而且，通常没有足够的参数检查 . 如果有人传递指向函数的指针，则该函数负责在它为NULL时不访问它 . （防御性编程） . 通常，函数不负责破坏内存或执行非法访问 .

  接下来，只要你有一个init函数，你也应该创建一个清理函数 . 这两者兼而有之 . initstack() 的签名有点缺乏，顺便说一下 . 只要有可能失败的东西（这里： malloc() ），该函数就会失败，因此它应该有一个状态返回值，这样调用者就可以对内存不足时堆栈没有按照需要真正初始化的事实作出反应（或堆碎片或其他可能导致malloc失败的东西） .

  void initstack(struct stack * p, int maxSize) {
      p->top = 0;
      p->maxSize = maxSize;
      p->a = malloc(maxSize * sizeof(int));
  }
  
  void uninitstack(struct stack* p) {
      free(p->a);
      p->a = NULL;
      p->maxSize = 0;
      p->top = 0;
  }
  

  这里有一些固定的推送功能，带有基本的错误检查代码：

  void push(struct stack * p, int item) {
      if (p == NULL){
          printf("Invalid argument. p == NULL.\n");
      }
      if (p->a == NULL) {
          printf("Stack not initialized.\n");
              return;
      }
      if (p->top == p->maxSize) {
          printf("Stack is full\n");
          return;
      }
      if (p->top < p->maxSize) {
          p->a[p->top] = item;
          p->top++;
      }
  }
  

  最后不仅仅是相应的pop功能：

  int pop(struct stack * p) {
      if (NULL != p)
      {
          if (NULL != p->a) {
              if (p->top == 0) {
                  printf("{}\n");
                  return -1000;
              }
              else {
                  p->top--;
                  return p->a[p->top];
              }
          }
      }
  }
  

  回复于 2024-05-07T11:42:18+08:00
• 3

  在 push() 例程中，您有：

  p->a = (int *)malloc(sizeof(int));
  

  但是你已经在 initstack() 例程中为 p->a 分配了空间 . 此代码消除了先前存储在堆栈中的任何内容 .

  回复于 2024-05-07T11:42:18+08:00
• 0

  //This program works perfectly
  
     #include<stdio.h>
       #include<stdlib.h>
       struct stack
         {
           int * a;
           int top;
           int maxSize;
         };
      void initstack(struct stack * p, int maxSize);
      void push(struct stack * p, int item);
      void display(struct stack p);
      int pop(struct stack * p);
      void printMenu();
  
        int main()  
         {
           struct stack p;
           int data,ch, data1, m;
           printf("Enter the maximum size of the stack\n");
           scanf("%d",&m);
           initstack(&p,m);
           do
             {
               printMenu();
               printf("Enter your choice\n");
               scanf("%d",&ch);
               switch(ch)
                 {
                    case 1:
                    printf("Enter the element to be pushed\n");
                    scanf("%d",&data);
                    push(&p, data);
                    break;
  
                    case 2:
                    data1 = pop(&p);
                    if(data1 != -1000)
                    printf("The popped element is %d\n",data1);
                    break;
  
                    case 3:
                    printf("The contents of the stack are");
                    display(p);
                    printf("\n");
                    break;
  
                    default:
                    return 0;
                 }
             }
          while(1);
          return 0;
        }
  
         void printMenu()
           {
            printf("Choice 1 : Push\n");
            printf("Choice 2 : Pop\n");
            printf("Choice 3 : Display\n");
            printf("Any other choice : Exit\n");
           }
  
          void initstack(struct stack * p, int maxSize) 
           {
        p->maxSize=maxSize;
        p->a=(int*)malloc(maxSize*sizeof(int));
        p->top=-1;
           }
  
         void push(struct stack * p, int item) 
           {
        if (p->top == p->maxSize - 1) {
            printf("Stack is full\n");
            return ;
         }
         p->top++;
         p->a[p->top] = item;
           }
  
          void display(struct stack p) 
           {
        int i,jp=0;
         for (i =0; i<=p.top; i++)
         {
            // if(p.top!=0)
             jp++;
            printf(" %d", p.a[i]);
         }
         if(jp==0)
         printf(" {}");
            }
  
      int pop(struct stack * p) 
      {
         int num;
         if (p->top == -1) {
            printf("Stack is empty\n");
            return -1000;
         }
         num = p->a[p->top];
         p->top--;
         return num;
          }
  

  回复于 2024-05-07T11:42:18+08:00