精华内容
下载资源
问答
  • c语言后缀表达式

    2020-03-25 18:17:44
    后缀表达式计算请使用已定义好的栈完成后缀表达式计算: (1)如果是操作数,直接入栈 (2)如果是操作符op,连续出栈两次,得到操作数x 和 y,计算 x op y,并将结果入栈。后缀表达式示例如下: 9 3 1 - 3 * + 10 2 /...

    栈 后缀表达式计算请使用已定义好的栈完成后缀表达式计算:
    (1)如果是操作数,直接入栈
    (2)如果是操作符op,连续出栈两次,得到操作数x 和 y,计算 x op y,并将结果入栈。后缀表达式示例如下:
    9 3 1 - 3 * + 10 2 / +
    13 445 + 51 / 6 -
    操作数、操作符之间由空格隔开,操作符有 +,-,*, /, %共 5 种符号,所有操作数都为整型。栈的定义如下:

    #define Stack_Size 50
    typedef struct{
        ElemType elem[Stack_Size];
        int top;
    }Stack;
    
    bool push(Stack* S, ElemType x);
    bool pop(Stack* S, ElemType *x);
    void init_stack(Stack *S);

    其中,栈初始化的实现为:

    void init_stack(Stack *S){
        S->top = -1;
    }
    

    实现代码:

    
    int compute_reverse_polish_notation(char* str)
    {
        int i = 0;
        Stack Numbers;
        init_stack(&Numbers);
        ElemType number_to_push, num1, num2;
        while (str[i] != '\0') {
            if (str[i] != ' ') {
                if (str[i] >= '0' && str[i] <= '9') {
                    number_to_push = 0;
                    while (str[i] != ' ' && str[i]) {
                        number_to_push = number_to_push * 10 + (str[i] - '0');
                        i++;
                    }
                    push(&Numbers, number_to_push);
                } else {
                    pop(&Numbers, &num2);
                    pop(&Numbers, &num1);
                    switch (str[i]) {
                    case '+': {
                        num1 += num2;
                        break;
                    }
                    case '-': {
                        num1 -= num2;
                        break;
                    }
                    case '*': {
                        num1 *= num2;
                        break;
                    }
                    case '/': {
                        num1 /= num2;
                        break;
                    }
                    case '%': {
                        num1 %= num2;
                        break;
                    }
                    }
                    push(&Numbers, num1);
                }
            } 
            i++;
        }
        pop(&Numbers, &num1);
        return num1;
    }
    展开全文
  • 使用c语言实现后缀表达式计算器

    千次阅读 2016-06-16 23:10:39
    使用栈来进行后缀表达式计算,流程:从前向后读取后缀表达式的项目,遇到数值压入栈中,遇到运算符pop出栈顶的两项做运算,运算结果再放入栈中直到= 例子:求后缀表达式4x*2x*a-c*+=? 1.把4和x压入栈中接下来...

    使用栈来进行后缀表达式计算,流程:从前向后读取后缀表达式的项目,遇到数值压入栈中,遇到运算符pop出栈顶的两项做运算,运算结果再放入栈中直到=

    例子:求后缀表达式4x*2x*a-c*+=?


    1.把4和x压入栈中接下来遇到了运算符*把4和x取出做*运算得到4x放入栈中,此时栈中有4x

    2.接下来2和x放入栈中遇到了运算符*把2和x取出做*运算得到2x放入栈中,此时栈中有4x,2x

    3.接下来遇到了a把a入栈,栈里项目为4x,2x,a,遇到预算符-,取出2x和a做-运算得到2x-a再放入栈,此时栈里是4x,2x-a

    4.接下来把c压入栈,栈里项目为4x,2x-a,c,遇到预算符*,取出2x-a和c,*运算得到(2x-a)c,再入栈,此时栈里是4x,(2x-a)c

    5.最后遇到+运算符,把栈中4x,(2x-a)c做+运算得到最终结果4x+(2x-a)c

    以上就是运用栈求后缀表达式的流畅,下面我们来用代码实现它:

    (代码来源:http://blog.csdn.net/woshinannan741/article/details/50087665)

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    #include <string>
    #include <stack>
    #include<algorithm>
    #define MAXN 1000
    using namespace std;
    stack<char> s;  //定义了一个栈


    char *tranfExp(char* exp)
    {
        char tempStr[1000];//保存后缀表达式的字符串


        int i=0,j=0;
        while(exp[i] !='\0')
        {
            if(exp[i]>='0' &&exp[i]<='9')  //如果是数字字符串就保存到后缀表达式字符串中
            {
                tempStr[j++] = exp[i];
            }
            else if(exp[i] == '(' )  //如果是左括号及入栈
            {
                s.push(exp[i]);
            }
            else if(exp[i] == ')' )  //如果是右括号就把接近栈顶的左括号上面所有的运算符出栈存进字符串中  左括号出栈
            {
                while(s.empty() == false)
                {
                    if(s.top() == '(' )
                    {
                        s.pop();
                        break;
                    }
                    else
                    {
                       tempStr[j++] = s.top();
                       s.pop();
                    }
                }
            }
            else if(exp[i] == '+' || exp[i] == '-')   //如果的事+-|操作符就把比他优先级高或者等于的所有运算符出栈进入字符串
            {
                while(s.empty() == false)
                {
                    char ch = s.top();
                    if(ch == '+'||ch == '-'||ch == '/'||ch == '*')
                    {


                       tempStr[j++] = s.top();
                       s.pop();
                    }
                    else
                        break;
                }
                s.push(exp[i]);
            }
            else if(exp[i] == '*' || exp[i] == '/')  //类似于扫描到+- 只是如果栈中有=-运算符就不用出栈  因为运算符优先级比较小
            {
                while(s.empty() == false)
                {
                    char ch = s.top();
                    if(ch == '/' || ch=='*')
                    {
                        tempStr[j++] = s.top();
                       s.pop();
                    }
                    else
                        break;
                }
                s.push(exp[i]);
            }
            i++;
        }
        while(s.empty() == false)   //把栈中剩余的所有运算符出栈
        {
            tempStr[j++] = s.top();
            s.pop();
        }
        tempStr[j] = 0;   //最后一个赋值为0  也就是字符串结束的标志
        return tempStr;   //返回已经得到的后缀表达式
    }
    int calcExp(char* exp)// 计算后缀表达式
    {
        puts(exp);   //展示已经得到的后缀
        while( !s.empty() )
          s.pop();
        int i=0;
        while(exp[i] != '\0')
        {
            if(exp[i]>='0' && exp[i]<='9')
            {
                s.push(exp[i]-'0');
            }
            else if(exp[i] == '-')
            {
                int m = s.top();
                s.pop();
                int n = s.top();
                s.pop();
                s.push(n-m);
            }
            else if(exp[i] == '+')
            {
                int m = s.top();
                s.pop();
                int n = s.top();
                s.pop();
                s.push(n+m);
            }
            else if(exp[i] == '/')
            {
                int m = s.top();
                s.pop();
                int n = s.top();
                s.pop();
                s.push(n/m);
            }
            else if(exp[i] == '*')
            {
                int m = s.top();
                s.pop();
                int n = s.top();
                s.pop();
                s.push(n*m);
            }
            i++;
        }
      /* while(s.empty() == false)
        {
             printf("%d",s.top());
             s.pop();
        }*/
        printf("\n\n\n");
        return s.top();
    }
    int main()
    {
       char str[1000];
       char* tranStr;
       tranStr = (char *)malloc(100*sizeof(char));
       printf("please input expression with kuohao:\n");
      // scanf("%s",str);
       str='2*(3+2)-5*2';
       tranStr =  tranfExp(str);//中缀表达式转换为后缀表达式函数
       //puts(tranStr); //输出转换后的后缀表达式
       printf("%d",calcExp(tranStr));
       return 0;
    }


    展开全文
  • 因为数据结构老师布置了栈的后缀表达式实验,经过思考,有以下反思。 中缀表达式转换为后缀表达式 关于括号,直接将括号里面的符号加入后缀表达式。 关于数字,直接推入后缀表达式 遇到±符号,如果栈为空或者栈顶...

    因为数据结构老师布置了栈的后缀表达式实验,经过思考,有以下反思。

    中缀表达式转换为后缀表达式

    1. 关于括号,直接将括号里面的符号加入后缀表达式。
    2. 关于数字,直接推入后缀表达式
    3. 遇到±符号,如果栈为空或者栈顶为“(”,直接将符号推入栈,如果栈不为空,且栈顶不为“(”,则推出栈顶符号。再将±符号推入符号栈。
    4. 如果遇到“/”符号,如果如果栈为空或者栈顶为“(”,直接推入栈,如果栈不为空,且栈顶符号优先级大于或者等于“/”符号,则推出栈顶符号。再将*/符号推入符号栈。
    5. 如果最后符号栈还有符号,直接加入后缀表达式。
      实际上也就是优先级比较的问题。

    后缀表达式的计算:
    后缀表达式的计算,只需要从左到右,遇到运算符就计算即可,无需考虑优先级的问题
    代码块如下

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    typedef struct node{
    	int data;
    	struct node *next; 
    }node,*link;
    typedef struct snode
    {
    	char c;
    	struct snode *next;
    }snode,*slink;
    
    void dealExpression();
    char opTop(slink &s);
    void push(link &s,int x);
    void push1(slink &s,char x);
    int pop1(slink &s);
    int pop(link &s);
    void calculate(link &s,slink &s1);
    int main(void)
    {
    	dealExpression();
    	
    }
    void empty(link &s)
    {
    	s=NULL;
    }
    void empty1(slink &s)
    {
    	s=NULL;
    }
    void push(link &s,int x)
    {	node *p=(link )malloc(sizeof(node));
    	p->data=x;
    	p->next=s;
    	s=p;
    }
    void push1(slink &s,char x)
    {	snode *p=(slink )malloc(sizeof(snode));
    	p->c=x;
    	p->next=s;
    	s=p;
    }
    int pop(link &s)
    {
    	int x;
    	if(s==NULL){
    		printf("it is an empty stack");
    
    	}
    	else{
    		x=s->data;
    		s=s->next;
    		return x;
    	}
    }
    int pop1(slink &s)
    {
    	snode *p=s;
    	char x;
    	if(s==NULL){
    		printf("it is an empty stack");
    	}
    	else{
    		x=p->c;
    		s=s->next;
    		free(p);
    		return x;
    	}
    }	
    char opTop(slink &s1){
    if(s1==NULL){
    	return 0;
    }
    else{
    	return s1->c;
    }
    }
    //计算,将栈中的数值和运算符进行计算 
    void calculate(link &s,slink &s1)
    {
    	int number1,number2;
    	char opf;
    	number1=pop(s);
    	number2=pop(s);
    	opf=pop1(s1);
    	int tmpResult=0;
    	switch(opf){
    			case '+':
    					tmpResult=number1+number2;
    				break;
    			case '-':
    					tmpResult=number2-number1;
    
    				break;
    			case '*':
    					tmpResult=number2*number1;
    					break;
    			case '/':
    					tmpResult=number2/number1;
    					break;
    	}
    	push(s,tmpResult);
    }
    
    //将中缀表达式转化为后缀,并且存储在数值中 
    void dealExpression()
    {
    	char change[100];
    	int i=0;
    	char a,b;
    	node *s;
    	snode *s1;
    //定义节点一定要初始化节点,要不然会发生分配内存错误 
    	empty(s);
    	empty1(s1);
    	char currentchar;
    	scanf("%c",&currentchar);
    //	转换过程 
    	while(currentchar!='='){
    	switch(currentchar){
    		case '+':
    		case '-':
    			if(opTop(s1)==0){
    				push1(s1,currentchar);
    			}
    			else{
    				while(opTop(s1)=='+'||opTop(s1)=='-'||opTop(s1)=='*'||opTop(s1)=='/')
    				{
    					a=pop1(s1);
    					change[i]=a;
    					i++;
    					printf("%c",a); 
    				}
    				push1(s1,currentchar);
    			}
    			scanf("%c",&currentchar);
    			break;
    		case '*':
    		case '/':
    			if(opTop(s1)==NULL){
    				push1(s1,currentchar);
    			}
    			else{
    				while(opTop(s1)=='*'||opTop(s1)=='/')
    				{
    					a=pop1(s1);
    					change[i]=a;
    					i++;
    					printf("%c",a);
    				}
    				push1(s1,currentchar);
    			}
    			scanf("%c",&currentchar);
    			break;
    		case '(':
    			push1(s1,currentchar);
    			scanf("%c",&currentchar);
    			break;
    		case ')':
    			while(opTop(s1)!='('){
    				b=pop1(s1);
    				change[i]=b;
    				i++;
    				printf("%c",b);
    			}
    			pop1(s1);
    			scanf("%c",&currentchar);
    			break;
    		default:
    			int opNum=0;
    			while(currentchar>='0'&currentchar<='9'){
    //				通过递归实现二位到以上的数 
    				opNum=opNum*10+currentchar-'0';
    				scanf("%c",&currentchar);
    			}
     			change[i]=char(opNum);
    			i++;
    			printf("%d",opNum);
    			break;
    					}
    		}
    		while(opTop(s1)!=0)
    		{
    			a=pop1(s1);
    			change[i]=char(a);
    			i++;
    			printf("%c",a);
    
    		}
    //		将转化的后缀表达式进行计算,如果遇到操作符,直接计算就可,无需考虑优先级,只需要考虑到从左至右的顺序 
    		int j=0;
    		while(j<i){
    			switch(change[j]){
    				case '+':
    				case '-':
    				case '*':
    				case '/':
    					push1(s1,change[j]);
    					calculate(s,s1);
    //					重要,因为break语句导致我调试了很久 
    					break;
    				default:
    				push(s,int(change[j])); 
    
    		}
    		j++;
    	}
    		while(opTop(s1)!=0){
    		calculate(s,s1);
    		}
    		int result;
    		result=pop(s);
    		printf("\n%d",result);
    
    }
    

    遇到的问题和反思:
    解决了上次中缀表达式中,地址分配错误的问题,因为上次中缀表达式,我没有将栈初始化,所以导致了地址分配错误,所以将栈初始化是很重要的。
    然后遇到了case,break的问题,我大意忘记写了break,结果导致了我调试了很久才发现问题:问题是这样的,我输入的 1+2= 结果却是45,在调试中发现“+”的ASCLL码正好是43,而且在最后一次case循环中,不仅是符号栈有输入,数字栈也有输入。才发现是忘记写break,导致最后一次循环:符号栈和数字栈都有输入,符号栈的输入是“+”,数字栈的输入是“43”.所以导致最后结果是45.

    展开全文
  • C语言计算前缀表达式

    2019-10-06 21:11:22
    算术表达式有前缀表示法、中缀表示法和后缀表示法等形式。前缀表达式指二元运算符位于两个运算数之前,例如2+3*(7-4)+8/4的前缀表达式是:+ + 2 * 3 - 7 4 / 8 4。请设计程序计算前缀表达式的结果值。 输入格式: ...

    算术表达式有前缀表示法、中缀表示法和后缀表示法等形式。前缀表达式指二元运算符位于两个运算数之前,例如2+3*(7-4)+8/4的前缀表达式是:+ + 2 * 3 - 7 4 / 8 4。请设计程序计算前缀表达式的结果值。

    输入格式:

    输入在一行内给出不超过30个字符的前缀表达式,只包含+-*\以及运算数,不同对象(运算数、运算符号)之间以空格分隔。

    输出格式:

    输出前缀表达式的运算结果,保留小数点后1位,或错误信息ERROR

    输入样例:

    + + 2 * 3 - 7 4 / 8 4
    

    输出样例:

    13.0

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    typedef struct node *Node;
    struct node {
    float num;
    char operators;
    int flag;
    Node Next;
    };
    Node ReadData(void);
    Node Function(Node);
    float Coculate(char,float,float);
    int main() {
    struct node head;
    Node temp=&head;
    do {
    temp->Next=ReadData();
    temp=temp->Next;
    } while(getchar()!='\n');
    temp->Next=NULL;

    temp=&head;
    while(temp->Next) {
    if(temp->Next&&temp->Next->Next&&temp->Next->Next->Next) {
    if(temp->Next->flag==1&&temp->Next->Next->flag==0&&temp->Next->Next->Next->flag==0) {

    float sum=Coculate(temp->Next->operators,temp->Next->Next->num,temp->Next->Next->Next->num);
    if(sum==99999)break;
    temp->Next->Next->Next->num=sum;
    temp->Next=temp->Next->Next->Next;
    temp=&head;
    } else temp=temp->Next;
    } else break;
    }
    if(head.Next->Next) {
    printf("ERROR");
    } else printf("%.1f",head.Next->num);
    return 0;
    }

    float Coculate(char c,float a,float b) {
    float sum;
    switch(c) {
    case '+':
    sum=a+b;
    break;
    case '-':
    sum=a-b;
    break;
    case '*':
    sum=a*b;
    break;
    case '/':
    if(!b)return 99999;
    sum=a/b;
    break;
    default :
    sum=99999;
    break;
    }
    return sum;
    }
    Node ReadData(void) {
    char a[31];
    Node temp=(Node)malloc(sizeof(struct node));
    scanf("%s",a);
    int len=strlen(a);
    if(len==1) {
    switch(a[0]) {
    case '+':
    case '-':
    case '*':
    case '/':
    temp->operators=a[0];
    temp->flag=1;
    break;
    default:
    temp->num=a[0]-'0';
    temp->flag=0;
    break;
    }
    } else {
    temp->num=0;
    temp->flag=0;
    if(a[0]>='0'&&a[0]<='9') {
    int i=0;
    for(; i<len&&a[i]!='.'; i++) {
    temp->num*=10;
    temp->num+=a[i]-'0';
    }
    float xiaoshu=1;
    for(++i; i<len; i++) {
    xiaoshu*=0.1;
    temp->num+=xiaoshu*(a[i]-'0');
    }
    } else {
    int i=1;
    for(; i<len&&a[i]!='.'; i++) {
    temp->num*=10;
    temp->num+=a[i]-'0';
    }
    float xiaoshu=1;
    for(++i; i<len; i++) {
    xiaoshu*=0.1;
    temp->num+=xiaoshu*(a[i]-'0');
    }
    if(a[0]=='-')temp->num*=-1;
    }
    }

    return temp;

    }

     

    转载于:https://www.cnblogs.com/didiaoxiaoguai/p/7544263.html

    展开全文
  • 将由数字和四则运算符组成的后缀表达式变换为中缀表达式。 输入的后缀表达式包含的运算符不超过15个。 要求转换后的中缀表达式中不应出现不必要的括号。 例如,整个表达式两端的括号要省略,不影响原计算结果的括号...
  • 大一菜鸟,初学编程,这是我的第一篇博客,希望能用博客记录我的成长之路。 初学数据结构,刚接触链表和栈,看到有中缀.../* 堆栈练习——中缀表达式转后缀表达式 */ #include #include #include #include<stdbool.h
  • 本实验取材于浙江大学《数据结构》,计算后缀表达式,关键在于理解堆栈的工作顺序 //堆栈的应用案例--表达式求值 //表达式求值的基本步数 //1当读入的是一个运算数时,把它被压入栈中; //2当读入的是一个运算符时,...
  • C语言后缀表达式计算--For初学者

    千次阅读 2018-09-26 20:19:25
    上次写了中缀转后缀,这次来计算后缀表达式的值,书接上文click here。 思路很简单,先扫描输入的后缀表达式,遇到数字就进栈,遇到运算符就出两个栈顶的元素运算,运算的结果再入栈。直到扫描完,并且栈内只剩下一...
  • c语言实现中缀表达式转后缀表达式并求得计算结果,用顺序栈结构。 当输入者输入错误信息的时候需要报错,并说明错误的种类。
  • C语言后缀表达式求值

    千次阅读 2018-12-16 23:06:48
    后缀表达式求值的算法是  遍历后缀表达式,如果遇到运算数,那么运算数入栈 如果遇到运算符,那么弹出栈里面两个元素,先弹出的是右运算数,后弹出的是左运算数,计算运算结果,然后将结果入栈。最后遍历到后缀...
  • 中缀转后缀算法 此算法分两步实现先将算术表达式转换为后缀表达式然后对后缀表达式进行计算具体实现方法如下 中缀转后缀 需要建一个操作符栈op和一个字符数组expop栈存放操作符字符数组用来存放转换以后的后缀表达式...
  •  最后得到的结果就是 一个反向的 后缀表达式 */ #include #include #include typedef double DateType; typedef char SymbolType; typedef struct RpnNode{ SymbolType symol; DateType data; ...
  • //进行子表达式计算 if(flag==0){ printf("被除数为零"); return 0; } s1[++top1]=result;//计算结果存入栈顶 return 1; } //计算表达式的函数 float getResult(char exp[]){ int i=0;//用于指向...
  • 计算后缀表达式——C语言实现

    千次阅读 2018-07-07 17:56:49
    printf("输入后缀表达式:"); while(c1!='#') { c1=getchar(); if(!operate(c1)) { push(s,(float) (c1-48)); } else { b=top(s); pop(s); a=top(s); pop(s); result=cal(a,...
  • C语言中,将中缀表达式转成后缀表达式,并计算它的结果,具体的思路如下: 1、定义两个栈,numStack用于存放运算对象,最后存放运算结果的,fuStack用于存放运算符号的 2、从左到右遍历字符串 3、如果当前的字符是...
  • C语言 : 中缀表达式 计算求值、后缀表达式 计算求值、中缀表达式 转 后缀表达式
  • 逆波兰表达式也叫后缀表达式,依靠一个栈将字符串全部按照逆波兰表达式方式压入,在之后弹出的处理中,能够依照顺序进行计算。相应还有前缀表达式(就是波兰表达式)和中缀表达式,想法都有区别。 下面是C语言代码:...
  • 通常人在书写的时候习惯是书写中缀表达式也叫逆波兰式,然而在计算机处理的时候中缀表达式的效率远小于后缀表达式,即操作数在前面,运算符在后面例如: 中缀表达式 A+B 后缀表达式AB+ A+BC------- ABC*+ AB+C*D ...
  • C语言中缀表达式转化为后缀表达式

    千次阅读 2018-12-12 17:18:51
    #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;...//后缀表示法计算时候的思路!!!先把元素推到栈中,每碰到一个 char stack[50]; char output[50];...
  • C高效计算后缀表达式

    2010-01-06 14:39:00
    本程序用C语言实现了高效地计算后缀表达式。/* 由于编译器的原因,本程序中的部分0需要改为NULL或/0。*/#include #include /* 结构:Operand 功能:建立链式栈,用于计算后缀表达式 注意: OperandStack变量在...
  • c语言数据结构实现后缀表达式求值

    万次阅读 多人点赞 2015-11-29 12:35:53
    通常人在书写的时候习惯是书写中缀表达式,然而在计算机处理的时候中缀表达式的效率远小于后缀表达式,即操作数在前面,运算符在后面例如: 中缀表达式 A+B 后缀表达式AB+ A+B*C ABC*+ A*B+C*D AB*CD*+
  • 在开始之前,我们首先要了解以下运算符在C语言中的优先级: ...这样的一个表达式就是中缀表达式(也称中序表达式),但由于这种表达式不容易被计算机解析,所以我们需要将其转化为后缀表达式! 后...
  • 本文实例为大家分享了C语言实现对后缀表达式(逆波兰表达式)的求解代码,供大家参考,具体内容如下 逆波兰表达式: 逆波兰表达式又叫后缀表达式。它是由相应的语法树的后序遍历的结果得到的。 例:5 – 8*(6 + 7) +...
  • 数据结构与算法分析——c语言描述 练习3.19 3.20 a b 答案 这道题以前发过文章。现在能支持幂^了。 栈的利用 挺重要的一个思想是 操作符 根据优先级分级 #include #include #include #include #include using ...
  • C语言处理综合表达式

    2021-04-30 17:22:41
    一种广为流行的做法是使用逆波兰式:即先把中缀表达式处理成后缀表达式,然后计算。但是我觉得,这种算法虽然高端,但是不太符合人类的思维,感觉没几年脑血栓还真想不出。难道除了这种方法,就真的没有其他的做法了...
  • 后缀表达式计算 请使用已定义好的栈完成后缀表达式计算: (1)如果是操作数,直接入栈 (2)如果是操作符op,连续出栈两次,得到操作数x 和 y,计算 x op y,并将结果入栈。 后缀表达式示例如下: 931-3*+102/+ ...
  • 大家好,C语言中自加自减——最简单的运算符操作了,也是前后缀——最容易搞混的语法,今天把它搞得明明白白。在前缀运算符中,例如 ++a,这个表达式的运算结果等价...需要注意的是,++a 在实际表达式计算的时候,...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 207
精华内容 82
关键字:

c语言计算后缀表达式

c语言 订阅