用栈实现队列，队列实现栈，判断合法出栈顺序

1.用栈实现队列

思路：

设置两个栈st1，st2。

入队时：若st1为空，直接入栈；否则，将st1内的数据全部出栈，入到st2中，将待入栈数据入到st1内，之后再把st2的数据全部出栈，入到st1中。

出队时，直接st1栈顶出栈，此时栈顶为先入的数据，实现FIFO。

注意：用类封装时需要重载<<

代码：

class myqueue
{
public:
	bool myempty()
	{
		return st1.empty();
	}
	void mypop()
	{
		if (!st1.empty())
			st1.pop();
		else
			printf("队列为空,无法出队列\n");
	}
	int myfront()
	{
		return st1.top();
	}
	void mypush(int v)
	{
		while (!st1.empty())
		{
			st2.push(st1.top());
			st1.pop();
		}
		st1.push(v);
		while (!st2.empty())
		{
			st1.push(st2.top());
			st2.pop();
		}
	}
	friend ostream& operator<<(ostream& os, myqueue& a);
private:
	stack<int> st1;
	stack<int> st2;
};
ostream& operator<<(ostream& out, myqueue& a)
{
	out << a.st1.top();
	return out;
}

测试主函数：

int main()
{
	myqueue qu;
	qu.mypush(1);
	qu.mypush(2);
	qu.mypush(3);

	
	cout << qu.myfront() << endl;
	qu.mypop();
	cout << qu.myfront() << endl;
	qu.mypop();

	qu.mypush(4);
	qu.mypush(5);

	for (;!qu.myempty();qu.mypop())
	{
		cout << qu.myfront() << endl;
	}
	qu.mypop();

}

 

2.用队列实现栈

思路：用一个队列，

数据入栈时，将该数据前面的所有数据出队列并再次入队列，此时入栈的元素为队头

出栈时，直接出队头元素，后进先出。

class mystack
{
public:
	bool myempty()
	{
		return qu.empty();
	}
	void mypop()
	{
		if (!qu.empty())
			qu.pop();
		else
			printf("栈为空,无法出栈\n");
	}
	int mytop()
	{
		return qu.front();
	}
	void mypush(const int v)
	{
		if (!qu.empty())
		{
			int n = qu.size();
			qu.push(v);
			while (n--)
			{
				int tmp = qu.front();
				qu.push(tmp);
				qu.pop();
			}
		}
		else
			qu.push(v);
	}
	friend ostream& operator<<(ostream& os, mystack& a);
private:
	queue<int> qu;
};
ostream& operator<<(ostream& out,mystack& a)
{
	out << a.qu.front();
	return out;
}

测试函数

int main()
{
	mystack qu;
	qu.mypush(1);
	qu.mypush(2);
	qu.mypush(3);


	cout << qu.mytop() << endl;
	qu.mypop();
	cout << qu.mytop() << endl;
	qu.mypop();

	qu.mypush(4);
	qu.mypush(5);

	for (; !qu.myempty(); qu.mypop())
	{
		cout << qu.mytop() << endl;
	}
	qu.mypop();

}

也可以在类里面用模板，自行定义数据类型，我在这里直接定义成int了。

---

3.判断合法出栈顺序

将1~n进行入栈，可以随入随出，也可以所有入完再出栈，现给定序列，判断是否是合法的出栈顺序。
  例如 {1 3 5 4 2} 合法 {3,1,5,4,2} 不合法

思路：自己设置一个栈，模拟给出的顺序出入栈，对比给出的顺序出栈元素是否与实际相同。设置一个int类型变量存已经入到的位置。

首先把给出出栈序列的第一个元素及其之前的元素入栈（如给出出栈顺序是3，1，5，4，2.则将1，2，3首先入栈），出一个栈顶元素（出3）

因为是按顺序入栈，当下一个元素比当前元素小时，说明没有入栈而是继续出栈了，

        对比此时的栈顶和下一个元素是否相同，若相同则顺序正确，出栈顶；

        若不相同说明出栈顺序不合法。（如3，1，5，4，2第二个元素1比第一个元素3小，是继续出栈，而此时栈顶元素为2，不是1，所以这个出栈顺序不合法）

当下一个元素比当前元素大时，说明先入栈再出栈，则自己的栈将元素入栈到直到与下一个元素相同，（如{1，3，5，4，2}，第二个元素3比第一个元素1大，栈入2，3），出栈顶（出3）。

若将顺序全部走完，则是合法出栈顺序。

实现：

bool Stack_out_right(vector<int>a)
{
	stack<int> st;
	vector<int>::iterator iter;
	int i;
	iter = a.begin();
	for (i = 1; i <= *iter; i++)//把第一个出的及其前面的入进去
	{
		st.push(i);
	}
	st.pop();//出第一个
	for (; iter != a.end() - 1; iter++)
	{
		if (*(iter + 1) < *iter)//如果下一个比当前的小：继续出
		{
			if (st.top() != *(iter + 1))//不按顺序出:不合法
			{
				return false;
			}
			st.pop();//出
		}
		else//下一个比当前大：入后再出
		{
			for (i; i <= *(iter + 1); i++)//继续入
			{
				st.push(i);
			}
			st.pop();//出
		}
	}
	if (iter == a.end() - 1)//如果遍历完了：合法
		return true;
}

测试

int main()
{
	cout << "1表示出栈顺序合法，0表示不合法：" << endl;
	vector<int> a = { 1,3,5,4,2};//合法
	cout << Stack_out_right(a) << endl;
	vector<int> b = { 3,1,5,4,2 };// 不合法
	cout << Stack_out_right(b) << endl;
}