栈的相关题目

栈的实现（数组）

#include<algorithm>
#include<cstddef>//size_t

template<typename T> class ArrayStack {
public:
	ArrayStack(int c = 100): capacity(c), top(-1) {
		data = new T[capacity]();
	}
	ArrayStack(const ArrayStack &rhs):capacity(rhs.capacity), top(rhs.top) {
		data = new T[capacity]();

		std::copy(rhs.data, rhs.data + capacity, data);
	}

	ArrayStack& operator=(ArrayStack rhs) {
		Swap(rhs);

		return *this;
	}

	~ArrayStack() {
		delete []data;
	}

	void Push(const T& val) {
		data[++top] = val;
	}

	void Pop()
	{
		if (top > -1)
			--top;
	}

	T& Top()
	{
		return data[top];
	}

	const T& Top() const 
	{
		return data[top];
	}

	bool Empty()
	{
		return top == -1;
	}

	std::size_t Size()
	{
		return top + 1;
	}

private:
	void Swap(ArrayStack &rhs) {
		std::swap(capacity, rhs.capacity);
		std::swap(top, rhs.top);
		std::swap(data, rhs.data);
	}

	int capacity;
	int top;
	T *data;
};

用两个栈实现队列

#include<cstddef>
#include<stack>

template <class T> class StackQueue {
 public:
	StackQueue(){}
	size_t size() {
		return s1.size() + s2.size();
	}

	bool empty() {
		return size() == 0;
	}

	void push(const T& val) {
		s1.push(val);
	}

	void pop() {
		if (s2.empty()) {
			while (!s1.empty()) {
				s2.push(s1.top());
				s1.pop();
			}
		}
		s2.pop();
	}

	T& front() {
		if (!s2.empty())
			return s2.top();
		while (!s1.empty()) {
			s2.push(s1.top());
			s1.pop();
		}
		
		return s2.top();
	}

 private:
	 std::stack<T> s1, s2;
};

栈的压入、弹出序列

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出序列。假设压入栈的所有数字均不相等。例如，序列1,2,3,4,5是某栈的压栈序列，序列4,5,3,2,1是该栈的对应的一个弹出序列，但4,3,5,2,1就不可能是该压栈序列的弹出序列。

#include<iostream>
#include<stack>

bool IsPopOrder(const int *pushorder, const int * poporder, int length) {
	if (pushorder == NULL || poporder == NULL || length <= 0)
		return false;

	std::stack<int> s;

	const int *pop_val = poporder;
	const int *push_val = pushorder;

	while (pop_val - poporder < length) { 
		while (s.empty() || s.top() != *pop_val) {
			if (push_val - pushorder == length) 
				break;

			s.push(*push_val++);
		}
		
		if (s.top() != *pop_val)
			return false;

		s.pop();
		pop_val++;
	}

	return true;

}