栈

定义栈的结构体

typedef struct 
{
    SElemType * base;//怎么base会关键字显示
    SElemType * top;
    int     stacksize;
}SqStack;

 

1.初始化一个空栈S

Status InitStack(SqStack & S)
{
    S.base=(SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
    if(!S.base)
        exit(OVERFLOW);
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    return OK;
}

 

2.判断是否为空栈

Status GetTop(SqStack S,SElemType & e)
{
    if(S.top==S.base)
        return ERROR;
    e=*(S.top-1);
    return OK;
}

 

3.插入元素e为新的栈顶元素

Status Push (SqStack & S ,SElemType e)
{
    if(S.top -S.base>=S.stacksize)//栈满，追加存储空间
    {
        //重新分配存储空间
        S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)* sizeof(SElemType));
        if(!S.base)    //存储空间分配失败
            exit(OVERFLOW);
        S.top=S.base+S.stacksize;
        S.stacksize+=STACKINCREMENT;
    }
    *S.top++=e;
    return OK;
    
}//Push

 

4.删除栈顶元素,用e返回其值

Status Pop(SqStack &S,SElemType &e)
{
    if(S.top==S.base)
        return ERROR;
    e=*--S.top;
    return OK;
}

 

5.应用十进制转八进制

void conversion()
{
    InitStack(S);
    scanf("%d",&N);
    while(N)
    {
        Push(S,N%8);
        N=N/8;
    }
    while(!StackEmpty(S))
    {
        Pop(S,e);
        printf("%d",e);
    }
}

 

6.

void LineEdit()
{
    InitStack(S);    //构造空栈
    ch=getchar();    //从终端接受第一个字符
    while(ch!=EOF)    //EOF表示全文结束
    {
        while(ch!=EOF&&ch!='\n')
        {
            switch(ch)
            {
                case '#':Pop(S,c);
                case '@':ClearStack(S);
                default:Push(S,ch);
            }//switch
            ch=getchar();
        }//while
    }//while
}//LineEdit

 

7.走迷宫

typedef struct 
{
    int     ord;
    PosType seat;
    int     di;
}SElemType;

Status MazePath(MazeType maze,PosType start,PosType end)
{
    InitStack(S);
    curpos=start;    //设定“当前位置”为入口位置
    curstep=1;        //探索第一步
    do
    {
        if(Pass(curpos))
        {
            FootPrint(curpos);        //留下足迹
            e=(curstep,curpos,1);
            Push(S,e);                //加入路径
            if(curpos==end)            //若到达终点出口
                return TRUE;
            curpos=NextPos(curpos,1);//下一位置是当前位置的东邻
            curstep++;                //探索下一步

        }//if
        else                //当前位置不能通过
        {
            if(!StackEmpty(S))
            {
                Pop(S,e);
                while(e.di==4&&!StackEmpty(S))
                {
                    MarkPrint(e.seat);
                    Pop(S,e);    //留下不能通过的标记，并退回一步
                }//while
                if(e.di<4)
                {
                    e.di++;
                    Push(S,e);    //换下一个方向探索
                    curpos=NextPos(e.seat,e.di);//设定当前位置是该方向上得相邻块
                }//if
            }//if
        }//else
    }while(!StackEmpty(S));
    return FALSE;
}//MazePath

 

8.运算优先级算法

OperandType EvaluateExpression()
{
    //设OPTR和OPND分别为运算符栈和运算数栈
    //OP为运算符集合
    InitStack(OPTR);
    Push(OPTR,'#');
    InitStack(OPND);
    c=getchar();
    while(c!='#'||GetTop(OPTR)!='#')//#是表达式的结束符
    {
        if(!In(c,OP))
        {            //不是运算符则进栈
            Push(OPND,c);
            c=getchar();
        }//if
        else
        {
            switch(Precede(GetTop(OPTR),c))
            {
                case '<':Push(OPTR,c);//栈顶元素优先权低
                c=getchar();break;
                case '=':Pop(OPTR,x);//脱括号并接收下一个字符
                c=getchar();break;
                case '>':Pop(OPTR,theta);//退栈并将运算结果入栈
                Pop(OPND,b);Pop(OPND,a);
                Push(OPND,Operate(a,theta,b));break;

            }//switch
        }//else
    }//while
    return GetTop(OPND);
}//EvaluateExpression