這個棧是以陣列形式實現。

先定義了一個結構體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;
}