C语言问题Stacks and Queues 队列，球da神忙帮，蟹蟹

Question

请问这个应该怎么做？要求是我们正确实现销毁函数（为 ADT 释放所有内存）并在您的客户端程序中正确使用它们，可以准确地管理内存。第一张是原题，第二张是机翻，下面第一个是stack.c，第二个是stack.h。请大lao帮我编程一下，蟹蟹.最下面的是别人写的，但是有报错，而且应该没有清理内存。第一个是stack.c,第二个是stack.h,第三个是balanced.c。

#include <stdlib.h>
#include <stdio.h>
#include  "Stack.h"
struct stack {
    int items[MAX_SIZE];
    int size;  
};
 
Stack *stackCreate(void) {
    Stack *s = malloc(sizeof (struct stack));
    if(s == NULL) {
        fprintf(stderr,"Insufficient Memory\n");
        exit(EXIT_FAILURE);
    }
    s->size = 0;
    return s;
}
void stackPush(Stack *s, int item) {
    int index = s->size;
    if(s->size < MAX_SIZE) {
        s->items[index] = item;
        s->size++;
    } else {
        fprintf(stderr,"Stack full\n");
        stackDestroy(s);
        exit(EXIT_FAILURE);
    }
}
 

#define MAX_SIZE 100
typedef struct stack Stack;
Stack *stackCreate(void);
void stackPush(Stack *s, int item);
int stackTop(Stack *s);
int stackPop(Stack *s);
int stackSize(Stack *s);
void stackDestroy(Stack *s);
 

#include <stdlib.h>
#include <stdio.h>
#include<malloc.h>
#include "Stack.h"
void Inital(struct stack* s)
{
    s->top = -1;
}
void stackPush(struct stack* s, int item) {
    if (s->top + 1 != MAX_SIZE)
    {
        s->items[s->top + 1] = item;
        s->top++;
    }
    else
    {
        fprintf(stderr, "Stack full\n");
        stackDestroy(s);
        exit(EXIT_FAILURE);
    }
}
int stackTop(struct stack* s)
{
    if (s->top == -1)
    {
    }
}
void stackPop(struct stack* s)
{
    if (s->top == -1)
    {
        fprintf(stderr, "Stack empty\n");
        exit(EXIT_FAILURE);
    }
    --(s->top);
}
int stackSize(struct stack* s)
{
    return (s->top) + 1;
}
void stackDestroy(struct stack* s)
        fprintf(stderr, "Stack empty\n");
        exit(EXIT_FAILURE);
    }
    return s->items[s->top];
{
    s->top = -1;
}
 

#pragma once
#define MAX_SIZE 100
struct stack {
    int items[MAX_SIZE];
    int top;
};
typedef struct stack Stack;
void Inital(struct stack* s);
void stackPush(struct stack* s, int item);
int stackTop(struct stack* s);
void stackPop(struct stack* s);
int stackSize(struct stack* s);
void stackDestroy(struct stack* s);
 

#include<stdio.h>
#include"Stack.h"
int main()
{
    int a = 0, b = 0, c = 0;
    stack s;
    Inital(&s);
    char ch;
    while ((ch = getchar()) != EOF)
    {
        stackPush(&s, ch);
        if (ch == '[')
        {
            ++a;
        }
        if (ch == ']')
        {
            --a;
        }
        if (ch == '{')
        {
            ++b;
        }
        if (ch == '}')
        {
            --b;
        }
        if (ch == '(')
        {
            ++c;
        }
        if (ch == ')')
        {
            --c;
        }
        else
        {
            continue;
        }
    }
    if (a == 0 && b == 0 && c == 0)
    {
        printf("Yes,balanced\n");
    }
    else
    {
        printf("No,not balanced\n");
    }
    stackDestroy(s);
}
 

Answer 1

balanced.c

#include<stdio.h>
#include"Stack.h"
int main()
{
    int balan = 1;
    Stack s;
    Inital(&s);
    char ch;
    while (balan && (ch = getchar()) != EOF && ch != '\n')
    {
        if (ch != '[' && ch != '{' && ch != '(' && ch != ']' && ch != '}' && ch != '}') // 忽略括号以外的字符
            continue;
        if (ch == '[' || ch == '{' || ch == '(') {
            stackPush(&s, ch);
        }
        else if(!stackSize(&s)){
            balan = 0;
        }
        else {
            switch (stackTop(&s)) {
                case '(':
                    balan = ch == ')' ? 1 : 0;
                    break;
                case '[':
                    balan = ch == ']' ? 1 : 0;
                    break;
                case '{':
                    balan = ch == '}' ? 1 : 0;
                    break;
            }
            stackPop(&s);
        }
    }
    if (balan)  printf("Yes,balanced\n");
    else        printf("No,not balanced\n");
    stackDestroy(&s);
    return 0;
}

stack.c

#include <stdlib.h>
#include <stdio.h>
#include<malloc.h>
#include "Stack.h"
void Inital(struct stack* s)
{
    s->top = -1;
}
void stackPush(struct stack* s, int item) {
    if (s->top + 1 != MAX_SIZE)
    {
        s->items[s->top + 1] = item;
        s->top++;
    }
    else
    {
        fprintf(stderr, "Stack full\n");
        stackDestroy(s);
        exit(EXIT_FAILURE);
    }
}
int stackTop(struct stack* s)
{
    if (s->top == -1)
    {
        fprintf(stderr, "Stack empty\n");
        exit(EXIT_FAILURE);
    }
    return s->items[s->top];
}
void stackPop(struct stack* s)
{
    if (s->top == -1)
    {
        fprintf(stderr, "Stack empty\n");
        exit(EXIT_FAILURE);
    }
    --(s->top);
}
int stackSize(struct stack* s)
{
    return (s->top) + 1;
}
void stackDestroy(struct stack* s){
        s->top = -1;
}

stack.h

#pragma once
#define MAX_SIZE 100
struct stack {
    int items[MAX_SIZE];
    int top;
};
typedef struct stack Stack;
void Inital(struct stack* s);
void stackPush(struct stack* s, int item);
int stackTop(struct stack* s);
void stackPop(struct stack* s);
int stackSize(struct stack* s);
void stackDestroy(struct stack* s);

给你改好了。
这一题是用栈进行括号匹配检查。
原本balanced.c的方法没有使用到自定义的栈，应该是违背了题目的意思，而且算法也存在漏洞——于是整个balanced.c几乎都修改了。
题目原代码中调用了malloc函数，是从堆中申请了内存。而别人写的那个是直接int items[MAX_SIZE];，从栈中申请了内存。
我是按着别人写的这个进行调试的，所以还是沿用了从栈中申请内存的操作。