数据结构六：栈和队列的应用---最小栈，两个栈实现一个队列，两个队列实现一个栈，保证栈的合法性

• 实现一个最小栈，存在push、pop和返回最小值Min(O(1))操作

      原理：定义一个结构体elem，包含data和min，第一次压栈时，将data = min，当每次压栈操作时都比较栈顶的min和data，如果min大于data就给min重新赋值，使得栈顶的min永远是最小值，最后返回栈顶的min就可以了。

头文件：

#pragma once
#include<iostream>
#include<stack>
using namespace std;
typedef int datatype;
struct elem
{
	datatype data;
	datatype min;
};
class MinStack
{
private:
	elem e;
	stack<elem> s;
public:
	MinStack()
	{
		e.data = 0;
		e.min = 0;
	}
	void push(datatype d);
	void pop();
	datatype& min();
};

#include"stackandqueue.h"

void MinStack::push(datatype d)
{
	e.data = d;
	e.min = d;
	if (s.empty())
	{
		s.push(e);
	}
	else
	{
		if (d <= s.top().min)
		{
			s.push(e);
		}
		else
		{
			e.min = s.top().min;
			s.push(e);
		}
	}
}
void MinStack::pop()
{
	s.pop();
}
datatype& MinStack::min()
{
	return s.top().min;
}

这道题还有一种思路，就是使用两个栈来实现一个最小栈，一个栈存数据，一个栈存最小值，不断更新最小值的栈，最后返回最小值时直接返回最小栈的栈顶即可。在出栈时如果data的栈顶和min的栈顶不同，则data出栈，否则同时出栈。

头文件

#pragma once
#include<iostream>
#include<stack>
using namespace std;
typedef int datatype;

class MinStack
{
private :
	stack<datatype> data;
	stack<datatype> mins;
public:
	void push(datatype d);
	void pop();
	datatype& min();
};

主文件

#include"stackandqueue.h"
void MinStack::push(datatype d)
{
	data.push(d);
	if (mins.empty())
	{
		mins.push(d);
	}
	else
	{
		if (d < mins.top())
		{
			mins.push(d);
		}
	}
}
void MinStack::pop()
{
	if (data.top() == mins.top())
	{
		data.pop();
		mins.pop();
	}
	else
	{
		data.pop();
	}
}
datatype& MinStack::min()
{
	return mins.top();
}

测试函数

#include"stackandqueue.h"

int main()
{
	MinStack s;
	s.push(3);
	s.push(2);
	s.push(4);
	s.push(6);
	s.push(1);
	s.min();
	return 0;
}

• 两个栈实现一个队列

     栈的特性是先进后出，而队列是先进先出，所以用栈实现队列的特性必须要两个栈，一个栈push，一个栈pop。

要注意的是判空的时候必须两个栈都为空才为空。

#pragma once
#include<iostream>
#include<stack>
using namespace std;
typedef int datatype;

class stacktoqueue
{
private:
	stack<datatype> s1;
	stack<datatype> s2;
public:
	void push(datatype d);
	void pop();
	datatype& GetTail();//获取尾
	datatype& GetHead();//获取头
	bool Empty();//判断是否为空
};

#include"stackandqueue.h"
void stacktoqueue::push(datatype d)
{
	s1.push(d);
}
void stacktoqueue::pop()
{
	if (!s2.empty())
	{
		s2.pop();
	}
	else
	{
		while (!s1.empty())
		{
			datatype a = s1.top();
			s1.pop();
			s2.push(a);
		}
		s2.pop();
	}
}
datatype& stacktoqueue::GetTail()
{
	if (!s1.empty())
	{
		return s1.top();
	}
	else
	{
		while (!s2.empty())
		{
			datatype a = s2.top();
			s2.pop();
			s1.push(a);
		}
		return s1.top();
	}
}
datatype& stacktoqueue::GetHead()
{
	if (!s2.empty())
	{
		return s2.top();
	}
	else
	{
		while (!s1.empty())
		{
			datatype a = s1.top();
			s1.pop();
			s2.push(a);
		}
		return s2.top();
	}
}
bool stacktoqueue::Empty()
{
	if (s1.empty() && s2.empty())
	{
		return true;
	}
	return false;
}

• 两个队列实现一个栈

      这道题看上去和上面的一样，其实不然，因为队列是先进先出的，所以如果是上面那种思路，那么两个队列无法相反，所以这里我们就设定一个队列放数据，另外一个队列当作中转站，入栈时将数据入q1,出队时先将q1中的前size-1个出队，然后入队到q2，再将q1中最后一个出队，然后一次将q2的元素出队并入队到q1。

#pragma once
#include<iostream>
#include<queue>
#include<stack>
using namespace std;
typedef int datatype;

class queuetostack
{
private:
	queue<datatype> q1;
	queue<datatype> q2;
public:
	void push(datatype d);
	void pop();
};

#include"stackandqueue.h"

void queuetostack::push(datatype d)
{
	q1.push(d);
}
void queuetostack::pop()
{
	if (q1.empty())
	{
		return;
	}
	else
	{
		while (q1.size() != 1)
		{
			datatype a = q1.front();
			q1.pop();
			q2.push(a);
		}
		q1.pop();
		while (!q2.empty())
		{
			datatype b = q2.front();
			q2.pop();
			q1.push(b);
		}
	}
}

 

• 保证元素的出栈入栈的合法性，例如入栈的序列(1,2,3,4,5)，则出栈的序列是(4,5,3,2,1)

     这道题我们可以用两个字符串来分别代表入栈序列和出栈序列

1.    找一个辅助栈，将入栈序列的第一个元素压栈。
2.    看栈顶元素是否和出栈序列的第一个元素相等，相等则出栈。 然后将第二个入栈序列的元素压栈，与出栈序列的下一个比。
3.    如果不相等，继续将入栈序列的元素压栈。重复上面的步骤
4. 如果出栈元素遍历完后，辅助栈为空，则为合法的出栈序列。

#include<iostream>
#include<stack>
bool IsTrue(int * arr1,int* arr2)
	{
		int len1 = sizeof(arr1) / sizeof(arr1[0]);
		int len2 = sizeof(arr2) / sizeof(arr2[0]);
		if (len1 != len2)
		{
			return false;
		}
		int j = 0;
		stack<int> s;
		for (int i = 0; i <= len1; i++)
		{
			s.push(arr1[i]);
			while (s.top() == arr2[j] && s.size() > 0)
			{
				s.pop();
				j++;
			}
		}
		return s.size() > 0 ? false : true;
	}
	int main()
	{
		int arr1[5] = { 1, 2, 3, 4, 5 };
		int arr2[5] = { 4, 5, 3, 2, 1 };
		IsTrue(arr1, arr2);
		return 0;
	
	}

•