Linux C计算多项式的计算器

计算器，计算多项式

#include <stdio.h>
#include "stack.h"
#include <string.h>

// 判断是否入栈
BOOL jud(Stack *s, int ope)
{
	if(Empty(s))
		return TRUE;
	
	int top = GetTop(s);
	
	switch(top)
	{
		case '+':
		case '-':    // * / (    需要入栈
			if ('*' == ope || '/' == ope || '(' == ope)
				return TRUE;
			break;
		case '*':
		case '/':    // (  需要入栈
			if('(' == ope )
				return TRUE;
			break;
		case '(':
			if (')' == ope)
			{
				Pop(s);
			}
			return TRUE;
		default:
			break;
	}
	
	
	return FALSE;
	
}

// 计算
void calc(Stack *s_opes, Stack *s_nums)
{
	int num1 = GetTop(s_nums);
	Pop(s_nums);
	
	int num2 = GetTop(s_nums);
	Pop(s_nums);
	
	int ope = GetTop(s_opes);
	Pop(s_opes);
	
	int res;
	switch(ope)
	{
		case '+':
			res = num1 + num2;
			break;
		case '-':
			res = num2 - num1;
			break;
		case '*':
			res = num1 * num2;
			break;
		case '/':
			res = num2 / num1;
			break;
		default:
			break;
	}
	
	Push(s_nums, res);    // 结果入栈
}

// 操作符处理函数
void deal_ope(Stack *s_opes, Stack *s_nums, int ope)
{
	// 判断入栈还是不入栈
	if (jud(s_opes, ope) == TRUE)
	{
		Push(s_opes, ope);
	}
	else   // 不入栈，需要计算，可能涉及多个符号的运算
	{
		while (jud(s_opes, ope) == FALSE)   
		{	
			calc(s_opes, s_nums);
		}
		
		// 符号需要入栈
		if (')' != ope)
			Push(s_opes, ope);
	}
}

int main()
{
	char buf[100];
	fgets(buf, 100, stdin);
	buf[strlen(buf)-1] = '\0';
	
	Stack s_nums;    // 操作数栈
	Stack s_opes;    // 操作符栈
	
	Init(&s_nums);
	Init(&s_opes);
	
	char *p = buf;
	while (*p)
	{
		if (*p >= '0' && *p <= '9')       // 处理操作数
		{
			int num = 0;
			while (*p >= '0' && *p <= '9')
			{
				num = num*10 + *p - '0';
				p++;
			}
			
			Push(&s_nums, num);      // 操作数入栈
			continue;
		}
		deal_ope(&s_opes, &s_nums, *p);   // 处理操作符
		p++;
	}
	
	
	// 计算剩余的数
	while (!Empty(&s_opes))
	{
		calc(&s_opes, &s_nums);
	}
	
	
	int res = GetTop(&s_nums);
	
	printf ("结果：%d\n", res);
	
	
	return 0;
}

功能函数

#include "stack.h"
#include <stdio.h>
#include <stdlib.h>
void Init(Stack *s)
{
	if (NULL == s)
		return;
	
	s->top = NULL;
}

BOOL Empty(Stack *s)
{
	if (NULL == s)
		return FALSE;
	
	if (NULL == s->top)
		return TRUE;
	
	return FALSE;
}

void Push(Stack *s, Data data)
{
	if (NULL == s)
		return;
	
	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
	if (NULL == node)
		return;
	
	node->data = data;
	node->next = s->top;
	s->top = node;
}

void Pop(Stack *s)
{
	if (NULL == s)
		return;
	
	if (Empty(s) == TRUE)
		return;
	
	Node *tmp = s->top;
	s->top = tmp->next;
	free(tmp);
}

Data GetTop(Stack *s)
{
	if (NULL == s)
		return;
	
	if (Empty(s) == TRUE)
	{
		printf ("无栈顶元素\n");
		exit(-1);  // 程序退出
	}
	
	return s->top->data;
}

头文件：

#ifndef _STACK_H_
#define _STACK_H_

#define SIZE 10

typedef enum {FALSE, TRUE} BOOL;
typedef int Data;
typedef struct node
{
	Data data;
	struct node *next;
}Node;

typedef struct stack 
{
	Node *top;
}Stack;

// 初始化栈
void Init(Stack *s);

// 判断空栈
BOOL Empty(Stack *s);

// 入栈
void Push(Stack *s, Data data);

// 出栈
void Pop(Stack *s);