请讲解一下这个代码的运行原理，150字以上（要详解）

#include"stdio.h"
#include"stdlib.h"
#include"string.h"
#include"math.h"
#define true 1
#define false 0
#define OPSETSIZE 8
typedef int Status;

unsigned char Prior[8][8] =
{ 
   
    /*'+'*/'>','>','<','<','<','>','>','<',
    /*'-'*/'>','>','<','<','<','>','>','<',
    /*'*'*/'>','>','>','>','<','>','>','<',
    /*'/'*/'>','>','>','>','<','>','>','<',
    /*'('*/'<','<','<','<','<','=',' ','<',
    /*')'*/'>','>','>','>',' ','>','>','>',
    /*'#'*/'<','<','<','<','<',' ','=','<',
    /*'^'*/'>','>','>','>','<','>','>','>'
};//后缀表达式压入栈需要符号转换 

typedef struct zhanchar
{
    char c;
    struct zhanchar *next;
}SC;       //zhanchar类型的结点SC

typedef struct zhanfloat
{
    float f;
    struct zhanfloat *next;
}SF;       //zhanfloat类型的结点SF

SC *Push(SC *s,char c)          //SC类型的指针Push，返回p
{
    SC *p=(SC*)malloc(sizeof(SC));
    p->c=c;
    p->next=s;
    return p;
}

SF *Push(SF *s,float f)        //SF类型的指针Push，返回p
{
    SF *p=(SF*)malloc(sizeof(SF));
    p->f=f;
    p->next=s;
    return p;
}

SC *Pop(SC *s)    //SC类型的指针Pop
{
    SC *q=s;
    s=s->next;
    free(q);
    return s;
}

SF *Pop(SF *s)      //SF类型的指针Pop
{
    SF *q=s;
    s=s->next;
    free(q);
    return s;
}

float counter(float a,unsigned char theta, float b)      //计算函数counter
{
    switch(theta)
    {
    case '+': return a+b;
    case '-': return a-b;
    case '*': return a*b;
    case '/': return a/b;
    case '^': return pow(a,b);
    default : return 0;
    }
}

char OPSET[OPSETSIZE]={'+','-','*','/','(',')','#','^'};

Status In(char Test,char *TestOp)
{
    int Find=false;
    for (int i=0; i< OPSETSIZE; i++)
    {
        if(Test == TestOp[i])
            Find= true;
    }
    return Find;
}

Status returnop(char op,char *TestOp)
{
    for(int i=0; i< OPSETSIZE; i++)
    {
        if (op == TestOp[i])
            return i;
    }
}

char precede(char Aop, char Bop)
{
    return Prior[returnop(Aop,OPSET)][returnop(Bop,OPSET)];
}

float counterexpre(char* expre)
{
    // 算术表达式求值的算符优先算法
    // 设OPTR和OPND分别为运算符栈和运算数栈，OP为运算符集合
    SC *OPTR=NULL;       // 运算符栈，字符元素
    SF *OPND=NULL;       // 运算数栈，实数元素
    char TempData[20];
    float Data,a,b;
    char theta,*c,Dr[]={'#','\0'};
    OPTR=Push(OPTR,'#');
    c=expre;
    strcpy(TempData,"\0");//字符串拷贝函数
    while (*c!= '#' || OPTR->c!='#')
    {
        if (!In(*c, OPSET))
        {
            Dr[0]=*c;
            strcat(TempData,Dr);           //字符串连接函数
            c++;
            if (In(*c, OPSET))
            {
                Data=atof(TempData);       //字符串转换函数(double)
                OPND=Push(OPND, Data);
                strcpy(TempData,"\0");
            }
        }
        else    // 不是运算符则进栈
        {
            switch (precede(OPTR->c, *c))
            {
            case '<': // 栈顶元素优先级低
                OPTR=Push(OPTR, *c);
                c++;
                break;
            case '=': // 脱括号并接收下一字符
                OPTR=Pop(OPTR);
                c++;
                break;
            case '>': // 退栈并将运算结果入栈
                theta=OPTR->c;OPTR=Pop(OPTR);
                b=OPND->f;OPND=Pop(OPND);
                a=OPND->f;OPND=Pop(OPND);
                OPND=Push(OPND, counter(a, theta, b));
                break;
            } //switch
        }
    } //while
    return OPND->f;
} //counterexpre

int main(void)
{
    char s[128];
    puts("请输入表达式:");
    gets(s);
    puts("该表达式的值为:");
    printf("%s\b=%g\n",s,counterexpre(s));
    system("pause");
    return 0;
}//使用说明:输入需要计算的算式并在后面缀上"#"号 

原理应该就是将输入的前缀表达式（包含加减乘除和次方的运算符），转换成后缀表达式之后，使用堆栈这一数据结构，对后缀表达式进行计算，最后得出表达式的结果。

将复杂数据结构的整个内容在处理它的每一步使用一小段代码按自己很容易理解的格式输出，非常有助于理解复杂算法和数据结构。
代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。
提醒：再牛×的老师也无法代替学生自己领悟和上厕所！
单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。