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

#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;
}