栈（数组）的基本操作

这个栈是以数组形式实现。

先定义了一个结构体StructRecord，结构体里包括三部分，栈的容量，栈顶元素的位置，和存储栈元素的数组，执行测试文件TestStack.c时需要输入栈的容量，以此来确定一个栈。

实现栈的一些规范操作，创造栈，插入，删除等。包括两个头文件Stack.h，fatal.h，库函数Stack.c，测试函数TestStack.c。头文件放的都是函数声明，库函数Stack.c放的的函数的定义。

fatal.h

#include<stdio.h>
#include<stdlib.h>
#define Error(Str) FatalError(Str)
#define FatalError(Str) fprintf(stderr, "%s\n", Str), exit(1);

Stack.h

 

typedef char ElementType;
#ifndef _Stack_H
#include<stdbool.h>
struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode Stack;

bool IsEmpty(Stack S);//判断栈是否为空
Stack CreatStack(void);//初始化一个栈
void Pop(Stack S);//对栈进行删除工作，只能弹出栈顶元素
void MakeEmpty(Stack S);//使得一个栈制空
void Push(ElementType X, Stack S);
ElementType Top(Stack S);
void DisposeStack(Stack S);
void PrintStake(Stack S);
void balance(char *ch, Stack S);//平衡符号，在字符数组查{},[],()是否匹配
#endif // !_Stack_H

 

 

 

Stack.c

#include "Stack.h"
#include<stdlib.h>
#include<stdio.h>
#include"fatal.h"
//结构体定义
struct Node
{
    ElementType Element;
    PtrToNode Next;
};

bool IsEmpty(Stack S)
{
    return S->Next == NULL;
}

//初始化一个栈
Stack CreatStack(void)
{
    Stack S;
    S = malloc(sizeof(struct Node));
    if (S == NULL) FatalError("Out of Space!")
    S->Next = NULL;
    MakeEmpty(S);//保证栈是个空栈
    return S;
}


//对栈进行删除工作，只能删除顶部元素
void Pop(Stack S)
{
    PtrToNode FirstCell;
    if (IsEmpty(S))
        Error("Empty Stack!")
    else
    {
        FirstCell = S->Next;
        S->Next = S->Next->Next;
        free(FirstCell);
    }
}

//使得一个栈制空
void MakeEmpty(Stack S)
{
    if (S==NULL)
        Error("Must use CreatStake first")
    else
    {
        while (!IsEmpty(S))
            Pop(S);
    }
}


//往栈S添加一个元素X
void Push(ElementType X, Stack S)
{
    PtrToNode TmpCell;
    TmpCell = malloc(sizeof(struct Node));
    if (TmpCell==NULL) FatalError("Out of Space!")
    else
    {
        TmpCell->Element = X ;
        TmpCell->Next = S->Next;
        S->Next = TmpCell;
    }
}

ElementType Top(Stack S)
{
    if (!IsEmpty(S)) return S->Next->Element;
    Error("Empty Space");
    return  0;/*Return value used to avoid warning*/
}

void DisposeStack(Stack S)
{
    MakeEmpty(S);
    free(S);
}

//打印栈，栈也没了
void PrintStake(Stack S)
{
    while (!IsEmpty(S))
    {
        printf("%d ", Top(S));
        Pop(S);
    }
}

//平衡符号，检查输入的算式是否正确只检查{},(),[]三种，例如(a+b){[d]c*d}{}是正确的，但是(a+b){{[d]c*d}{}不对
void balance(char * ch, Stack S)
{
    ElementType c;
    MakeEmpty(S);
    while ((c = *ch) != '\0')//一个一个读入字符，直到遇到字符数组结束符
    {
        printf("%c ", c);//打印出读入的字符
        switch (c)
        {
        //如果是开放符号{,(,[，就推入栈中，除此之外的任何符号都不推入栈中
        case '(':
        case '[':
        case '{': Push(c, S); break;       //然后停止switch

       //如果是封闭符号}，），]，分情况
        case ')':
            if (IsEmpty(S))//如果栈为空，说明字符数组不平衡
            {
                fprintf(stderr, "The symbols not balance!\n");
                return;
            }
            else
            {
                if (Top(S) == '(')//当读入")"时，而此时栈顶符号为"("，匹配
                {
                    Pop(S);//就把栈顶元素出栈
                }
                else//否则就不平衡
                {
                    fprintf(stderr, "The symbols not balance!\n");
                    return;
                }
            }
            break;
        //其他情况一样
        case ']':
            if (IsEmpty(S))
            {
                fprintf(stderr, "The symbols not balance!\n");
                return;
            }
            else
            {
                if (Top(S) == '[')
                {
                    Pop(S);
                }
                else
                {
                    fprintf(stderr, "The symbols not balance!\n");
                    return;
                }
            }
            break;
        case '}':
            if (IsEmpty(S))
            {
                fprintf(stderr, "The symbols not balance!\n");
                return;
            }
            else
            {
                if (Top(S) == '{')
                {
                    Pop(S);
                }
                else
                {
                    fprintf(stderr, "The symbols not balance!\n");
                    return;
                }
            }
            break;
        default:
            break;
        }
        ch++;
    }
    if (IsEmpty(S))
    {
        fprintf(stdout, "The Symbols Balance!\n");
    }
    else
    {
        fprintf(stderr, "The Symbols Not Balance!\n");
    }
}

 

 

TestStack.c

 

#include "Stack.h"
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
int main()
{
    //Stack S;
    //S = CreatStack();
    //printf("随机生成多少位数:");
    //long  amount;
    //scanf_s("%d", &amount);
    //srand((unsigned)time(NULL));
    //for (long i = 0; i < amount; i++)
    //    Push(rand() % 1000,S);//插入元素
    //PrintStake(S);
    //DisposeStack(S);//释放栈
    char ch[] = "(a+b){[d]c*d}{}";
    Stack S = CreatStack();
    balance(ch, S);
    return 0;
}

 

 

 

转载于:https://www.cnblogs.com/xinlovedai/p/6264892.html