用栈实现表达式求值结果总是显示第一个输入的值？？

我的想法是判断优先级跟计算分开，计算值时候如果操作符栈不为空弹出栈顶元素，同时从操作数栈中弹出栈顶操作数，计算结果后再压入操作数栈，如果计算完了肯定最后操作数栈里就有一个元素直接取出来就是结果。但是编译的时候他只显示第一个输入的数，写了测试程序发现Push和Pop没错，大神们看看我哪里错了啊？

```c
```#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char OP[]={'+', '-', '*', '/', '(', ')', '#'};
char rule[][7]=
        {
                {'>','>','<','<','<','>','>'},
                {'>','>','<','<','<','>','>'},
                {'>','>','>','>','<','>','>'},
                {'>','>','>','>','<','>','>'},
                {'<','<','<','<','<','=','0'},
                {'>','>','>','>','0','>','>'},
                {'<','<','<','<','<','0','='}
        };


typedef struct Stack_OP
{
    char data;
    struct Stack_OP *next;
}Stack_OP;

typedef struct Stack_ON
{
    float data;
    struct Stack_ON *next;
}Stack_ON;

void InitStack_OP(Stack_OP **mystack)
{
    (*mystack)=(Stack_OP*)malloc(sizeof(Stack_OP));
    (*mystack)->data=-1;
    (*mystack)->next=NULL;
}

void InitStack_ON(Stack_ON **mystack)
{
    (*mystack)=(Stack_ON*)malloc(sizeof(Stack_ON));
    (*mystack)->data=-1;
    (*mystack)->next=NULL;
}

void Push_OP(Stack_OP **mystack, char data)
{
    Stack_OP *temp;
    temp=malloc(sizeof(Stack_OP));

    temp->data=data;
    temp->next=(*mystack);

    (*mystack)=temp;
}

void Push_ON(Stack_ON **mystack, float data)
{
    Stack_ON *temp;
    temp=malloc(sizeof(Stack_ON));

    temp->data=data;
    temp->next=(*mystack);

    (*mystack)=temp;
}

int IsEmptyStack_OP(Stack_OP *mystack)
{
    return mystack==NULL;
}

int IsEmptyStack_ON(Stack_ON *mystack)
{
    return mystack==NULL;
}

char Pop_OP(Stack_OP **mystack)
{
    Stack_OP *temp;
    char data;
    if(IsEmptyStack_OP(*mystack))
    {
        printf("栈已空!\n");
        return NULL;
    }
    temp=(*mystack);
    data=temp->data;
    (*mystack)=(*mystack)->next;
    free(temp);
    return data;
}

float Pop_ON(Stack_ON **mystack)
{
    Stack_ON *temp;
    float data;
    if(IsEmptyStack_ON(*mystack))
    {
        printf("栈已空!\n");
        return -1;
    }
    temp=(*mystack);
    data=temp->data;
    (*mystack)=(*mystack)->next;
    free(temp);
    return data;
}

char Top_OP(Stack_OP *mystack)
{
    char data;
    if(IsEmptyStack_OP(mystack))
        return 0;
    return mystack->data;
}

float Top_ON(Stack_ON *mystack)
{
    float data;
    if(IsEmptyStack_ON(mystack))
        return 0;
    return mystack->data;
}

void DeleteStack_OP(Stack_OP **mystack)
{
    Stack_OP *temp, *p;
    p=(*mystack);
    while (p->next)
    {
        temp=p->next;
        p->next=temp->next;
        free(temp);
    }
    free(p);
}

void DeleteStack_ON(Stack_ON **mystack)
{
    Stack_ON *temp, *p;
    p=(*mystack);
    while (p->next)
    {
        temp=p->next;
        p->next=temp->next;
        free(temp);
    }
    free(p);
}

int Precede(char a, char c)
{
    int i,j;
    for(i=0;i<7;i++)
    {
        if(a==OP[i])
        {
            break;
        }
    }
    for(j=0;j<7;j++)
    {
        if(c==OP[j])
        {
            break;
        }
    }
    if(rule[i][j]=='0')
    {
        return -2;
    }
    if(rule[i][j]=='=')
    {
        return 0;
    }
    if(rule[i][j]=='>')
    {
        return 1;
    }
    if(rule[i][j]=='<')
    {
        return -1;
    }
}

float comvalue(float top, float second, char cal)
{
    switch (cal)
    {
        case '+':
            return top + second;
        case '-':
            return top - second;
        case '*':
            return top * second;
        case '/':
            return top / second;
    }
}

void Calculate(Stack_OP **OPTR, Stack_ON **OPND)
{
    Stack_OP *p=(*OPTR);
    Stack_ON *q=(*OPND);
    InitStack_OP(&p);
    InitStack_ON(&q);
    Push_OP(&p, '#');
    Push_ON(&q, '#');
    char biaoDaShi[30];
    printf("请输入算数表达式!(10以内)\n");
    scanf("%s", biaoDaShi);
    if (IsEmptyStack_OP(p))
    {
        Push_OP(&p, biaoDaShi[0]);
    }
    if (IsEmptyStack_ON(q))
    {
        if (biaoDaShi[0]>='0' && biaoDaShi[0]<='9')
        {
            Push_ON(&q, biaoDaShi[0]-48);
        }
    }
    for(int i=0;biaoDaShi[i]!='#';i++)
    {
        if (biaoDaShi[i]>='0' && biaoDaShi[i]<='9')
        {

            Push_ON(&q, biaoDaShi[i]-48);
            break;
        }
        else
        {
            char temp=Top_OP(p);
            int Result=Precede(temp, biaoDaShi[i]);
            switch (Result){
                case 1:
                {
                    Push_OP(&p, biaoDaShi[i]);
                    break;
                }
                case -1:
                {
                    char cal=Pop_OP(&p);
                    float top=Pop_ON(&q);
                    float second=Pop_ON(&q);
                    float res=comvalue(top, second, cal);
                    Push_ON(&q, res);
                    break;
                }
                case 0:
                {
                    printf("输入的算数表达式不正确");
                    break;
                }
            }
        }
    }
    float end=q->data;
    printf("%f\n", end);
}

int main()
{
    Stack_OP *OPTR;
    Stack_ON *OPND;
    InitStack_OP(&OPTR);
    InitStack_ON(&OPND);
    Calculate(&OPTR, &OPND);
    Stack_ON *a;
    InitStack_ON(&a);
    Push_ON(&a,2);
    Push_ON(&a, 3);
    printf("%f\n", Pop_ON(&a));
    printf("%f\n", Pop_ON(&a));
    printf("%f\n", Pop_ON(&a));
    printf("%f\n", Pop_ON(&a));
    return 0;
}