【数据结构】动态栈+括号匹配+逆波兰表达式（后缀表达式计算）

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>//动态栈的简单实现
#include<assert.h>

#define  DEFAULTSIZE 3
using namespace std;
template<class T>
class Stack
{
public:
	Stack()
		:_array(NULL)
		, _size(0)
		, _capacity(0)
	{
		
	}
	void Push(const T& data)
	{
		CheckCapacity();
		_array[_size] = data;
		_size++;

	}
	void Pop()
	{
		if (_size == 0)
		{
			cout << "已经为空不能弹出数据" << endl;
			return;
		}
		_size--;
	}
	T& Top()
	{
		return _array[_size-1];
	}
	T& Top()const
	{
		return _array[_size-1];
	}
	size_t Size()const
	{
		return _size;
	}
	bool Empty()const
	{
		return 0 == _size;
	}
	void DisPlay()
	{
		for (size_t i = 0; i < _size; i++)
		{
			cout << _array[i] <<" ";
		}
		cout << endl;
	}
private:
	void CheckCapacity()
	{
		if (_size == _capacity)
		{
			int *p = new int[_size+DEFAULTSIZE];
			for (size_t i = 0; i < _size; i++)
			{
				p[i] = _array[i];
			}
			delete[] _array;
			_array = p;
			_capacity = _size + DEFAULTSIZE;

		}
	}

	T* _array;
	size_t _capacity;
	size_t _size;
};
void FunTest()
{
	Stack<int> s;
	s.Push(0);
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	s.DisPlay();
	cout << s.Top() << endl;
	s.Pop();
	s.DisPlay();
	s.Pop();
	s.DisPlay();
	cout << s.Top() << endl;
	cout << s.Size() << endl;
	cout << s.Empty() << endl;
	s.Pop();
	cout << s.Empty() << endl;
	s.Pop();
	cout << s.Empty() << endl;
	s.Pop();
	cout << s.Empty() << endl;
	s.Pop();
}

#include<iostream>//括号匹配
#include<assert.h>
#include<stack>
using namespace std;

bool IsMatch(char  c)
{
	if (c == '('||c == ')' || c == '{'|| c == '}' || c == '['||c == ']')
	
		return true;
	
	return false;
}
bool MatchBrackets(char* pStr)
{
	assert(pStr);
	stack <char> s;
	int len = strlen(pStr);
	for (int i = 0; i < len; ++i)
	{
		if (!IsMatch(pStr[i]))
			continue;
		if (pStr[i] == '(' || pStr[i] == '{' || pStr[i] == '[' )
			{
				s.push(pStr[i]);
			}
			else
			{
				if (s.empty())
				{
					cout << "右括号比左括号多" << endl;
					return false;
				}
				else
				{
					char c = s.top();
					if (pStr[i] == ')'&&c == '(' || pStr[i] == '}'&&c == '{' || pStr[i] == ']'&&c == '[')
					{
						s.pop();

					}

					else
					{
						cout << "左括号次序匹配错误" << endl;
						return false;
					}

				}
				
			}
		}
	if (s.empty())
	{
		cout << "括号匹配正确" << endl;
		return true;
	}

	else
	{
		cout << "左括号比右括号多" << endl;
		return false;
	}
	}




void FunTest2()
{
	char a[] = "(())abc{[(])}"; // 左右括号次序匹配不正确
	char b[] = "(()))abc{[]}"; // 右括号多于左括号
	char c[] = "(()()abc{[]}"; // 左括号多于右括号
	char d[] = "(())abc{[]()}"; // 左右括号匹配正确

	MatchBrackets(a);
	MatchBrackets(b);
	MatchBrackets(c);
	MatchBrackets(d);
	
	
}
int main()
{
	FunTest2();
	system("pause");
	return 0;
}
#include<iostream>//逆波兰表达式（后缀表达式）
#include<stack>
#include<assert.h>
using namespace std;
enum OPERATOR{ ADD, SUB, MUL, DIV, DATA };
struct Cell
{
	OPERATOR _op;
	int _data;
};
int CalRPN(Cell * RPN, int size)
{
	stack<int> s;
	for (int i = 0; i < size; i++)
	{
		if (DATA == RPN[i]._op)
		{
			s.push(RPN[i]._data);
		}
		else
		{
			int right = s.top();
			s.pop();
			int left = s.top();
			s.pop();
			switch (RPN[i]._op)
			{
			case ADD:
				s.push(left + right);
				break;
			case SUB:
				s.push(left - right);
				break;
			case MUL:
				s.push(left * right);
				break;
			case DIV:
				if (0==right)
				{
					cout << "除数为零" << endl;
				}
				s.push(left / right);
				break;
			default:
				assert(0);
				break;


			}
			
		}
	}
	return s.top();
}
int main()
{
	Cell RPN[] = { { DATA, 2 }, { DATA, 3 }, { DATA, 4 },
	{ ADD, 0 }, { MUL, 2 }, { DATA, 6 }, { SUB, 0 }, { DATA, 8 }, { DATA, 2 },
	{ DIV, 0 }, { ADD, 2 } };
	cout << CalRPN(RPN, sizeof(RPN) / sizeof(RPN[0])) << endl;
	system("pause");
	return 0;
}