数据结构实验之栈二：一般算术表达式转换成后缀式

最重要的是搞清楚元素符的高低

1：比较元素高于栈顶元素直接入栈；

2：若比较元素低于栈顶元素，则栈中元素出栈，进入数组（或栈，但输出的话得从栈底输出）直到遇到低于比较元素的，此时比较元素入栈；

3：若比较元素为左括号，直接入栈；

4：若比较元素为右括号，则栈顶元素一直出栈，进入数组（或栈），直到遇到左括号，与右括号相抵消；

5：其他数据均入数组（或栈）；

最后顺序输出

小知识点一结：1：定义函数时，若不是VOID，则一定要给他一个返回值。

                          2：指针有不同类型的指针，要根据类型的不同，设不同的指针。不如说，结构体型指针，整型指针，字符型指针。

数据结构实验之栈二：一般算术表达式转换成后缀式

Time Limit: 1000MS  Memory Limit: 65536KB

Submit  Statistic

Problem Description

对于一个基于二元运算符的算术表达式，转换为对应的后缀式，并输出之。

Input

输入一个算术表达式，以‘#’字符作为结束标志。

Output

输出该表达式转换所得到的后缀式。

Example Input

a*b+(c-d/e)*f#

   
   

    
    
Example Output
     
     

      
      
ab*cde/-f*+
     
     
   
   

  
  

   
   
代码
   
   

    
    
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define STACKINCREMENT 10000     //存储空间分配增量
#define STACKINITSIZE 10000    //存储空间初始分配量
typedef char SElemType;
typedef struct
{
    SElemType *base;//定义栈底指针；
    SElemType *top;//定义暂定指针，
    int stacksize;//当前已分配的存储空间
}SqStack;
int InitStack(SqStack *S)  //初始化栈
{
    S->base = (SElemType *)malloc(STACKINITSIZE*sizeof(SElemType));//为栈底开辟空间
    if(!S->base)
        return 0;//如果开辟空间失败，返回为0；
    S->top= S->base;
    S->stacksize = STACKINITSIZE;//S->stacksize为开辟的空间
    return 1;
}
int Push(SqStack *S,char e)//入栈函数
{
    if(S->top - S->base>=S->stacksize)//先判断空间是否足够
    {
        S->base = (SElemType *)realloc(S->base, (S->stacksize + STACKINCREMENT)*sizeof(SElemType));//新开的空间，用realloc函数
        if(!S->base)
            return 0;//如果创建失败，返回0
        S->top = S->base + S->stacksize;//再次确定S->top的地址，防止S->base改变。而丢失了S->top的地址
        S->stacksize = S->stacksize + STACKINCREMENT;//更新S->stacksize
    }
    *(S->top) = e;//进行进栈操作
    S->top++;
    return 1;
}

int Clear(SqStack *S)//清空栈函数
{
    S->top = S->base;//让top指向base
    return 1;
}

void Display(SqStack *S)
{
   char *temp;//定义一个字符型指针
   temp = S->base;
   while(temp!=S->top)
   {
       printf("%c",*(temp));
       temp++;
   }
}
int Compare(char s)
{
     if(s=='#')
        return 1;
    else if(s=='(')
        return 2;
     else if(s=='+'||s=='-')
            return 3;
        else if(s=='*'||s=='/')
                    return 4;
                    return 0;
}
int Judge(SqStack * L,char s,SqStack *H)
{
    int h1,h2;
    if(s=='+'||s=='-'||s=='*'||s=='/')//加减乘除判断优先级
    {
        h1 = Compare(s);
        h2 = Compare(*(L->top-1));
        if(h1>h2)//若高于直接入栈
           Push(L,s);
        else
        {
             L->top--;
           while(h1<=Compare(*(L->top)))//否则栈顶元素出栈，直到遇到比自己运算级低的元素，入栈。
           {                             //还有一个问题，比如，栈顶元素为‘+’，比较元素为‘-’，
               Push(H,*(L->top));       //则‘+’高于‘-’，先入栈的元素，运算符高。
               L->top--;
            }
            L->top++;
            Push(L,s);
        }

    }

       else if(s=='(')//、若为左括号直接入栈
               Push(L,s);
       else if(s==')')//若为右括号，则让栈中的元素一一出栈。直到遇到左括号，相互抵消。
       {
           L->top--;
           while(*(L->top)!='(')
           {
               Push(H,*(L->top));
               L->top--;
            }
       }
       else if(s>='a'&&s<='z')
           Push(H,s);
       return 1;
}
int Pop(SqStack *S, SqStack *H)//出栈函数，若判断到‘#’时，栈中仍有元素，则全部出栈，并进入到另一个栈中
{
    while(S->top!=S->base+1)
    {
        *(H->top) = *(S->top-1);
        H->top++;
        S->top--;
    }
    return 1;
}
int main()
{
   SqStack S;
   InitStack(&S);
   S.top = S.base+1;
   *(S.base) = '#' ;
    SqStack H;
   InitStack(&H);
   char s[10000];
   gets(s);
   int n = strlen(s);
   int i;
   for(i = 0;i<=n-1;i++)
   {
       if(s[i]=='#')
       break;
       Judge(&S,s[i],&H);
   }
   Pop(&S,&H);
   Display(&H);//栈中所有元素出栈、
   printf("\n");

    return 0;
}