本文目录一览：
用c语言的栈来编写逆波兰公式的程序
如题，代码如下，欢迎探讨！！！
/*
表达式的后缀表示及其求值
*/
#include <stdio.h>
typedef int ElemType;
/*
考虑到char型运算时的隐形提升会溢出，此处定义为int，代价仅浪费了内存空间
*/
#define MAXNUM 16
struct stack
{
ElemType data[MAXNUM];
int top;
};
void StackInit(struct stack *stack)
{
int i = 0;
for (; i < MAXNUM; i++)
{
stack->data[i] = 0;
}
stack->top = 0;
/*
栈底部从索引0处开始
*/
}
void StackPush(struct stack *stack, ElemType c)
{
if (MAXNUM == stack->top)
/* 栈中元素最多有MAXNUM - 1个 */
{
printf("The stack is full\n");
return;
}
stack->data[stack->top++] = c;
}
ElemType StackPop(struct stack *stack)
{
if (0 == stack->top)
{
printf("The stack is empty\n");
/* 当栈空时，若返回0是错误的 */
return 0;
}
return stack->data[--stack->top];
}
void PostfixEvaluation(struct stack *stack)
{
return;
/* 这个函数非常简单了，所有的麻烦都已经解决了，我实在不想完成它 */
}
int ChangeToPostfix(char *str)
{
int i = 0, flag = 0;
/* flag 用来标记连续数字的出现，没想到好点的办法 */
int c, ch;
struct stack ch_stack;
struct stack op_stack;
StackInit(&ch_stack);
StackInit(&op_stack);
while ('\0' != (c = *(str + i)))
/* 此处需注意的是:如果是静态的字符串，以'\0'为结束条件,如果是用户输入的，则以'\n'为结束条件 */
{
if (('+' == c) || ('/' == c) || ('(' == c))
{
flag = 0;
StackPush(&op_stack, c);
}
else if (')' == c)
{
flag = 0;
while ('\0' != (c = StackPop(&op_stack)))
{
StackPush(&ch_stack, c);
}
if (0 == op_stack.top)
{
printf("the ( hasnt found when the ) come in!\n");
return -1;
}
}
else if (('+' == c) || ('-' == c))
{
flag = 0;
/* +和-优先级低，运算符栈中的((如果存在)后的所有运算符需推出 */
if (0 != op_stack.top)
/* 你可以不在此处添加top的检查，那样，你可以发现StackPop错误返回的0被拾取了 */
{
/* 被逼无奈,只得在此检查top值，无法寄希望于StackPop了 */
while ('\0' != (ch = StackPop(&op_stack)))
{
StackPush(&ch_stack, ch);
if (0 == op_stack.top)
{
break;
}
}
}
StackPush(&op_stack, c);
}
else if ((c >= '0') && (c <= '9'))
/* 对于表达式中2位或多位连续的数字，需特殊处理 */
{
if (0 == flag)
{
StackPush(&ch_stack, (c - '0'));
flag = 1;
}
else
{
StackPush(&ch_stack, 10 * StackPop(&ch_stack) + (c - '0'));
}
}
i++;
}
while (0 != op_stack.top)
/* 表达式处理结束，将运算符栈中的所有运算符推出并压入字符栈 */
{
StackPush(&ch_stack, StackPop(&op_stack));
}
PostfixEvaluation(&ch_stack);
/* 该函数放在此处可能较为欠妥，可是，只要完成了任务不就OK了么，难道你会在乎？ */
/* just test */
for (i = 0; i < ch_stack.top; i++)
{
if ('+' == ch_stack.data[i])
{
printf("+..");
}
else if ('-' == ch_stack.data[i])
{
printf("-..");
}
else if ('*' == ch_stack.data[i])
{
printf("*..");
}
else if ('/' == ch_stack.data[i])
{
printf("/..");
}
else
{
printf("%d..", ch_stack.data[i]);
}
}
return 0;
}
int main(void)
{
char str[] = "12+34*435-5/1";
/* just test */
printf("The result should be :");
printf("12 34 435 * + 5 1 / - [= 8]");
if (-1 == ChangeToPostfix(str))
{
printf("ChangeToPostfix() error");
return 1;
}
return 0;
}
C语言编写逆波兰计算器
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#define STACK_SIZE 20
int make_empty(void);
bool is_empty(void);
bool is_full(void);
void push(char);
void pop(char);
void stack_overflow(void);
void stack_underflow(void);
char contents[STACK_SIZE] = {0}, top;
int main(int argc, char *argv[])
{
char ch = '1';
while (ch != 'q')
{
make_empty();
printf("Enter an RPN expression:");
do
{
scanf(" %c", &ch);
if (ch >= '1' && ch <= '9')
push(ch);
else if (ch == '+' || ch == '-' || ch == '*' || ch == '/')
{
top--;
pop(ch);
}
else if (ch == '=')
{
if ((top - 1) == 0)
pop(ch);
else
printf("Number not used!");
break;
}
else if (ch == '\n')
;
else
{
ch = 'q';
break; /* 其它情况置为退出标志q */
}
} while (ch != '\n');
}
return 0;
}
int make_empty(void)
{
return top = 0;
}
bool is_empty(void)
{
return top == 0;
}
bool is_full(void)
{
return top == STACK_SIZE;
}
void push(char ch)
{
if (is_full())
stack_overflow();
else
contents[top++] = ch - '0';
}
void pop(char ch)
{
if (is_empty())
stack_underflow();
else
switch (ch)
{
case '+':
contents[top - 1] += contents[top];
break;
case '-':
contents[top - 1] -= contents[top];
break;
case '*':
contents[top - 1] *= contents[top];
break;
case '/':
contents[top - 1] /= contents[top];
break;
case '=':
printf("Value of expression:%d\n", (int)contents[0]);
break;
}
}
void stack_overflow(void)
{
printf("Expression is too complex!");
exit(EXIT_FAILURE);
}
void stack_underflow(void)
{
printf("Not enough operands in expression!");
exit(EXIT_FAILURE);
}
C语言 逆波兰表达式 算法
#include <stdio.h>
#include <string.h>
int main()
{
double d[100], *dp = d;
int m, k;
char t[50], *tp = t;
char s[100], *c = s;
char *op = "+-*/";
char *fg = "0123456789.";
gets(s);
while (*c)
{
if (strchr(op, *c))
{
*tp++ = *c;
k = 0;
}
else if (strchr(fg, *c))
{
sscanf(c, "%lf%n", dp++, &m);
c += m - 1;
++k;
}
++c;
while ((dp - d > 1 && k == 2) || (!*c && dp - d == 1))
{
switch (*--tp)
{
case '+':
dp[-2] = dp[-2] + dp[-1];
break;
case '-':
dp[-2] = dp[-2] - dp[-1];
break;
case '*':
dp[-2] = dp[-2] * dp[-1];
break;
case '/':
dp[-2] = dp[-2] / dp[-1];
break;
}
--dp;
}
}
printf("%f", *dp);
}
C语言求解逆波兰表达式
使用栈完成
int add(char s[])
{
int st[100];
char *p;
int top = -1;
int A, B, sum = 0;
for (p = s; *p != 0; p++) // 进行数值计算
{
switch (*p)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
st[++top] = *p - '0';
break; // 是数字压入总栈st中
case '+':
case '-':
case '*':
case '/': // 是运算符号
A = st[top--];
B = st[top--]; // 弹出2个数字
switch (*p)
{
case '+':
sum = B + A;
break;
case '-':
sum = B - A;
break;
case '*':
sum = B * A;
break;
case '/':
sum = B / A;
break;
}
st[++top] = sum; // 将结果重新压入栈
break;
}
}
return sum;
}
