栈和队列相关面试题

1，用两个栈实现一个队列

template<class T>
class CQuee
{
public:
	CQuee()
	{}

	~CQuee()
	{}

	void Push(const T& node);
	T Pop();
private:
	stack<T> stack1;
	stack<T> stack2;
};

template<class T>
void CQuee<T>::Push(const T& node)
{
	stack1.push(node);
}

template<class T>
T CQuee<T>::Pop()
{
	T tmp = 0;
	if (stack2.empty())
	{
		while (!stack1.empty())
		{
			tmp = stack1.top();
			stack2.push(tmp);
			stack1.pop();
		}
	}
	tmp = stack2.top();
	stack2.pop();
	return tmp;
}

void TestCQuee()
{
	CQuee<int> cq;
	cq.Push(1);
	cq.Push(2);
	cq.Push(3);
	cq.Push(4);
	cout<<cq.Pop()<<endl;
}

2，使用两个队列实现一个栈

template<class T>
class Stack
{
public:
	void Push(const T& data);
	T Pop();
	int Getnum()const;
	Stack()
	{
		_count = 0;
	}
private:
	queue<T> q1;
	queue<T> q2;
	int _count;
};

template<class T>
int Stack<T>::Getnum()const
{
	return _count;
}

template<class T>
void Stack<T>::Push(const T& data)
{
	if (q1.size() == 0 && q2.size() == 0)
	{
		q1.push(data);
	}
	else if (q1.size() > 0)//q1不为0,q2为0时，将数据插入q1
	{
		q1.push(data);
	}
	else//q1为0，q2不为0时，将数据插入q2
	{
		q2.push(data);
	}
	++_count;
}

template<class T>
T Stack<T>::Pop()
{
	T ret;
	if (q2.size() == 0)
	{
		while (q1.size() != 1)
		{
			T& data = q1.front();
			q1.pop();
			q2.push(data);
		}
		ret = q1.front();
		q1.pop();
		cout << ret << endl;
	}
	else
	{
		while (q2.size() != 1)
		{
			T & data = q2.front();
			q2.pop();
			q1.push(data);
		}
		ret = q2.front();
		q2.pop();
		cout << ret << endl;
	}
	--_count;
	return ret;
}

void TestStack()
{
	Stack<int> s;
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	s.Pop();
}

3，使用一个数组实现两个栈

#include<assert.h>
enum Stack
{
	First,
	Second,
};

template<class T>
class ArrayStack
{
public:
	ArrayStack()
		:_n(5)
		, _a(new T[_n])
		, size1(0)
		, size2(_n - 1)
	{}

	~ArrayStack()
	{
		if (_a)
		{
			delete _a;
			_a = NULL;
		}
	}

	void Push(Stack s, T data)
	{
		assert(_a);
		if (size1 > size2)
		{
			_Expand();
		}
		if (s == First)
		{
			_a[size1++] = data;
		}
		else
		{
			_a[size2--] = data;
		}
	}

	void Pop(Stack s)
	{
		if (s == First)
		{
			if (size1 == NULL)
			{
				cout << "Stack1 is empty" << endl;
				return;
			}
			--size1;
		}
		else if (s == Second)
		{
			if (size2 == _n-1)
			{
				cout << "Stack2 is empty" << endl;
				return;
			}
			++size2;
		}
	}
protected:
	void _Expand()
	{
		size_t n = _n;
		_n *= 2;
		T* tmp = new T[_n];
		for (size_t i = 0; i < size1; ++i)
		{
			tmp[i] = _a[i];
		}
		size_t newsize = n - size2;//保存栈2的元素个数
		size2 += n + 1;//将栈2的栈顶指针相应的向后移动增加的字节数

		//将栈2中旧空间的内容拷贝到新空间中
		for (size_t i = _n - 1; --size2; --i)
		{
			tmp[i] = _a[--n];//注意循环条件和赋值方式
		}
		size2 = _n - newsize;
		delete[]_a;//释放旧空间
		swap(_a, tmp);//指向新空间
	}
private:
	size_t _n;
	T* _a;
	size_t size1;//栈1的栈顶下标
	size_t size2;//栈2的栈顶下标
};

4，实现一个栈，要求实现Push,Pop,Min（返回最小值）的操作的时间复杂度是O(1)

template<class T>
class StackMin
{
public:
	StackMin()
	{}

	~StackMin()
	{}

	void Push(const T& x)
	{
		s.push(x);
		if (min.empty() || x <= min.top())
		{
			min.push(x);
		}
	}

	void Pop()
	{
		if (s.empty())
			return;
		if (s.top() == min.top())
			min.pop();
		s.pop();
	}

	T Min()
	{
		return min.top();
	}
protected:
	stack<T> s;
	stack<T> min;//用来存放最小元素
};

void TestStackMin()
{
	StackMin<int> s;
	s.Push(4);
	s.Push(3);
	s.Push(5);
	s.Push(1);
	s.Push(1);
	s.Push(2);

	s.Pop();
	s.Pop();
}