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

结构堆栈有一个指向动态分配数组（用于保存堆栈内容）的指针“a”、一个保存此数组大小的整数“maxSize”（即此数组中可以保存的最大数据数）和一个存储堆栈中顶层元素的数组索引的整数“top”

在initstack函数中，将top的值初始化为-1，并初始化maxSize的值。 尝试将数据推入完整堆栈时，在推送功能中打印消息“堆栈已满”。 在pop函数中打印消息“Stack is empty”，并在尝试从空堆栈弹出数据时返回值-1000

在initstack函数中，将top的值初始化为-1，并初始化maxSize的值

尝试将数据推入完整堆栈时，在推送功能中打印消息“堆栈已满”

在pop函数中打印消息“Stack is empty”，并在尝试从空堆栈弹出数据时返回值-1000

注意，语句“堆栈的内容是”在main函数中。在显示函数中，如果堆栈为空，则打印“{}”

我的代码有问题：

---

• 它没有获取所需数量的值
• 其次，我无法打印元素

   #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->top=-1;
         p->maxSize=maxSize;
       }
  
     void push(struct stack * p, int item) 
       {
         if (p->top == p->maxSize-1) 
           {
            printf("Stack is full\n");
            return;
           }
      p->a = (int *)malloc(sizeof(int));
      p->top++;
      p->a[p->top] =item;
      p->maxSize--;
  
     }
  
      void display(struct stack p) 
       {
         struct stack *p1;
         p1=&p;
         int a[30],n=0,i;
         for (i = p1->top ; i >= 0; i--)
          {
            printf("\n%d", p1->a[i]);
  
          }
  
        }
  
       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;
      }
  

  #包括
  #包括
  结构堆栈
  {
  int*a；
  int top；
  int-maxSize；
  };
  void initstack（结构堆栈*p，int maxSize）；
  void push（结构堆栈*p，int项）；
  无效显示（结构堆栈p）；
  int-pop（结构堆栈*p）；
  作废打印菜单（）；
  int main（）
  {
  结构栈p；
  int数据，ch，data1，m；
  printf（“输入堆栈的最大大小\n”）；
  scanf（“%d”、&m）；
  initstack&p，m；
  做
  {
  打印菜单（）；
  printf（“输入您的选择\n”）；
  scanf（“%d”和“ch”）；
  开关（ch）
  {
  案例1：
  printf（“输入要推送的元素\n”）；
  scanf（“%d”和数据）；
  推送（p&p，数据）；
  打破
  案例2：
  数据1=pop&p；
  如果（数据1！=-1000）
  printf（“弹出的元素是%d\n”，数据1）；
  打破
  案例3：
  printf（“堆栈的内容为”）；
  显示器（p）；
  printf（“\n”）；
  打破
  违约：
  返回0；
  }
  }
  而(1),；
  返回0；
  }
  无效打印菜单（）
  {
  printf（“选项1:Push\n”）；
  printf（“选择2:Pop\n”）；
  printf（“选项3：显示”）；
  printf（“任何其他选择：退出”）；
  }
  void initstack（结构堆栈*p，int maxSize）
  {
  p->top=-1；
  p->maxSize=maxSize；
  }
  void push（结构堆栈*p，int项）
  {
  如果（p->top==p->maxSize-1）
  {
  printf（“堆栈已满\n”）；
  返回；
  }
  p->a=（int*）malloc（sizeof（int））；
  p->top++；
  p->a[p->top]=物料；
  p->maxSize--；
  }
  无效显示（结构堆栈p）
  {
  结构堆栈*p1；
  p1=&p；
  int a[30]，n=0，i；
  对于（i=p1->top；i>=0；i--）
  {
  printf（“\n%d”，p1->a[i]）；
  }
  }
  int-pop（结构堆栈*p）
  {
  int-num；
  如果（p->top==-1）
  {
  printf（“堆栈为空\n”）；
  返回-1000；
  }
  num=p->a[p->top]；
  p->顶部--；
  返回num；
  }
  

在您的

push（）

例程中，您有：

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

但是您已经在

initstack（）

例程中为

p->a

分配了空间。

---

这段代码正在清除以前存储在堆栈中的内容。

这段代码中出现了很多错误

首先，正确格式化代码的Olafs注释可能看起来很苛刻，但它是合理的。根据您使用的编辑器，只需按两次键即可。（例如，Visual Studio中的CTRL-k-f）。为了让代码进入问题，秘诀是（同样在VS中）：CTRL-a（标记全部）选项卡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 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++;
    }
}

//这个程序运行得很好
#包括
#包括
结构堆栈
{
int*a；
int top；
int-maxSize；
};
void initstack（结构堆栈*p，int maxSize）；
void push（结构堆栈*p，int项）；
无效显示（结构堆栈p）；
int-pop（结构堆栈*p）；
作废打印菜单（）；
int main（）
{
结构栈p；
int数据，ch，data1，m；
printf（“输入堆栈的最大大小\n”）；
scanf（“%d”、&m）；
initstack&p，m；
做
{
打印菜单（）；
printf（“输入您的选择\n”）；
scanf（“%d”和“ch”）；
开关（ch）
{
案例1：
printf（“输入要推送的元素\n”）；
scanf（“%d”和数据）；
推送（p&p，数据）；
打破
案例2：
数据1=pop&p；
如果（数据1！=-1000）
printf（“弹出的el
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++;
    }
}

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];
            }
        }
    }
}

//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;
        }