栈的链表实现

/*
  栈是限制插入和删除只能在一个位置上进行的表，该位置是表的末端（最后进入栈的元素位置），叫做栈的顶。
  栈具有后进先出的特点，用链表实现时可采用首插法实现这一特性。
  对于栈，进栈操作要检查栈是否有空间；出栈和取栈顶值要检查栈是否为空栈。
*/

/*栈的链表实现*/

/*接口头文件*/
typedef int ElementType;

#ifndef _STACK_H
#define _STACK_H
#include <stdbool.h>

struct Node;
typedef struct Node * PtrToNode;
typedef PtrToNode Stack;
typedef PtrToNode Position;

/*操作集*/
bool IsEmpty( Stack S );
Stack CreateStack( void );
void MakeEmpty( Stack S );
void Pop( Stack S );
void Push( ElementType X, Stack S );
ElementType Top( Stack S );
void DisposeStack( Stack S );
void PrintfStack( Stack S );

#endif 


/*接口实现*/
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"

/*特定结构体定义*/
struct Node
{
    ElementType Element;
    Position Next;
};

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

Stack CreateStack( void )
{
    Stack S;
    
    S = ( Stack )malloc( sizeof( struct Node ) );
    if ( S == NULL )
    {
       printf( "No Space!!!\n" );
       exit( 1 );
    }
    S->Next = NULL;
    /*确保S是空栈*/ 
    MakeEmpty( S );
    
    return S;
}

void MakeEmpty( Stack S )
{
    Position P;
    
    if ( S == NULL )
    {
       printf( "No use  CreateStack!!!\n" );
       exit( 1 );
    }
    else
        while ( ! IsEmpty( S ) )
            Pop( S );
}

void Pop( Stack S )
{
    Position P;
    
    if ( IsEmpty( S ) )
    {
       printf( "Stack is empty!!!\n" );
       exit( 1 );
    }
    else
    {
        P = S->Next;
        S->Next = S->Next->Next;
        free( P );
    }
}

void Push( ElementType X, Stack S )
{
    Position P;
    
    P = ( Stack )malloc( sizeof( struct Node ) );
    if ( P == NULL )
    {
       printf( "No Space!!!\n" );
       exit( 1 ); 
    }
    else
    {
        P->Element = X;
        P->Next = S->Next;
        S->Next = P;
    }
}

ElementType Top( Stack S )
{
    if ( IsEmpty( S ) )
    {
       printf( "Stack is empty!!!\n" );
       exit( 1 );
    }
    else
        return S->Next->Element;
}

void DisposeStack( Stack S )
{
    /*
    Position P;
    
    while ( S->Next != NULL )
    {
        P = S->Next;
        S->Next = S->Next->Next;
        free( P );
    }
   */
    MakeEmpty( S );
    /*释放栈头*/ 
    free( S );
}

/*打印栈，且把栈变为空栈*/
void PrintfStack( Stack S )
{
    while ( ! IsEmpty( S ) )
    {
        printf( "%3d", Top( S ) );
        Pop( S );
    }
    printf( "\n" );
}


//平衡符号，检查输入的算式是否正确只检查{},(),[]三种，例如(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");
    }
}