编译环境vs2008
Stack.h
#pragma once
#include <assert.h>
#include <stdio.h>
#include <string.h>
//typedef int DataType; //基本操作使用
//typedef char DataType; //括号匹配问题使用
typedef int DataType; //逆波兰表达式使用
#define MAX_SIZE 10
typedef struct Stack
{
DataType _array[MAX_SIZE];
int _size;
}Stack;
//栈的初始化
void StackInit(Stack* s);
//入栈操作
void StackPush(Stack* s,DataType data);
//出栈
void StackPop(Stack* s);
//获取栈顶元素
DataType StackTop(Stack* s);
//获取栈内元素的个数
int StackSize(Stack* s);
//判断栈是否为空
int StackEmpty(Stack* s);
//判断括号是否匹配
int MatchBrackets(const char* pStr);
//以下的三个都是逆波兰表达式范畴
//创建一个枚举类型
typedef enum{ADD,SUB,MUL,DIV,DATA}OPERATOR;
//创建一个结构体
typedef struct Cell
{
OPERATOR _op;
int _data;
}Cell;
//逆波兰表达式
int CalaRPN(Cell * RPN, int size);
Stack.c
#include "Stack.h"
//栈的初始化
void StackInit(Stack* s)
{
assert(s);
s->_size = 0;
}
//入栈操作
void StackPush(Stack* s,DataType data)
{
assert(s);
if(s->_size == MAX_SIZE)
return;
s->_array[s->_size++] = data;
}
//出栈
void StackPop(Stack* s)
{
assert(&s);
if(StackEmpty(s))
return;
s->_size--;
}
//获取栈顶元素
DataType StackTop(Stack* s)
{
assert(s);
return s->_array[s->_size-1];
}
//获取栈内元素的个数
int StackSize(Stack* s)
{
assert(s);
return s->_size;
}
//判断栈是否为空
int StackEmpty(Stack* s)
{
assert(s);
return 0 == s->_size;
}
//判断字符是否是括号
int IsBracket(char ch)
{
if('(' == ch || ')' == ch ||
'[' == ch || ']' == ch ||
'{' == ch || '}'== ch)
{
return 1;
}
return 0;
}
//判断括号是否匹配
int MatchBrackets(const char* pStr)
{
int i = 0;
int size = strlen(pStr);
Stack s;
StackInit(&s);
for(; i<size; ++i)
{
if(!IsBracket(pStr[i]))
continue;
else
{
//当前字符为括号
//当前字符为左括号
if('(' == pStr[i] || '[' == pStr[i] || '{' == pStr[i])
StackPush(&s,pStr[i]);
else
{
char ch;
//当前字符为右括号
if(StackEmpty(&s))
{
printf("右括号比左括号多\n");
return 0;
}
ch = StackTop(&s);
if(ch == '(' && pStr[i] == ')' ||
ch == '[' && pStr[i] == ']' ||
ch == '{' && pStr[i] == '}')
{
StackPop(&s);
}
else
{
printf("左右括号的次序匹配出错!!!\n");
return 0;
}
}
}
}
if(!StackEmpty(&s))
{
printf("左括号比右括号多!!!\n");
return 0;
}
printf("左右括号匹配正确!!!\n");
return 1;
}
int CalaRPN(Cell * RPN, int size)
{
int i = 0;
Stack s;
StackInit(&s);
for(; i<size; ++i)
{
if(RPN[i]._op == DATA)
StackPush(&s,RPN[i]._data);
else
{
int left = 0,right = 0;
right = StackTop(&s);
StackPop(&s);
left = StackTop(&s);
StackPop(&s);
switch(RPN[i]._op)
{
case ADD:
StackPush(&s,left+right);
break;
case SUB:
StackPush(&s,left- right);
break;
case MUL:
StackPush(&s,left*right);
break;
case DIV:
if(0 == right)
{
printf("除法的右操作数为0非法!!!\n");
return 0;
}
StackPush(&s,left/right);
break;
default:
printf("无法进行操作!!!\n");
return 0;
}
}
}
return StackTop(&s);
}
test.c
#include "Stack.h"
//栈的基本操作
void StackTest();
//括号匹配
void test();
//逆波兰表达式
void test1();
int main()
{
//StackTest();
//test();
test1();
return 0;
}
//栈的基本操作
void StackTest()
{
Stack s;
StackInit(&s);
StackPush(&s,2);
StackPush(&s,3);
StackPush(&s,4);
StackPush(&s,5);
printf("栈内一共有%d个元素\n",StackSize(&s));
printf("栈顶元素是%d\n",StackTop(&s));
printf("%d\n",StackEmpty(&s));
StackPop(&s);
StackPop(&s);
printf("栈内一共有%d个元素\n",StackSize(&s));
printf("栈顶元素是%d\n",StackTop(&s));
printf("%d\n",StackEmpty(&s));
}
//括号是否匹配
void test()
{
//char * str = "(())abc{[(])}";
//char a[] = "(()))abc{[]}";
char b[] = "(()()abc{[]}";
char c[] = "(())abc{[]()}";
MatchBrackets(c);
}
//逆波兰表达式
void test1()
{
Cell RPN[] = {{DATA,12},{DATA,3},{DATA,4},{ADD,0},
{MUL,0},{DATA,6},{SUB,0},{DATA,8},{DATA,2},{DIV,0},
{ADD,0}};
printf("%d\n",CalaRPN(RPN,sizeof(RPN)/sizeof(RPN[0])));
}