栈的应用

编译环境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])));
}