面试题那些事（3）—栈

栈的定义--Stack

栈只允许在末端进行插入和删除的线性表。栈具有后进先出的特性（LIFO，Last In First Out）。

问题：

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

问题分析：

根据栈的特性要实现入栈和出栈是比较容易的，只需要借助系统给的stack即可。但是最难的是要满足Min（返回最小值的操作）

的时间复杂度为O(1)

我们先来讨论最一般的思路：

思路1

使用一个变量来保存最小的值_min，每次入栈时让入栈的元素d和_min进行比较，如果d<_min则更新_min,否则不更新。

但是这存在一个很大的问题，如果最小值出栈了怎么办？

比如说有一个栈为：8,10,6,2,9.

则_min的值为2，9出栈的话那么_min的值不受影响。但是如果2出栈的话，则_min的值就无法得到。

思路2

既然只用一个变量没法解决这个问题，那我们就增加变量。_min 保存当前的最小值，_second 保存次小值。

但是在实现Pop的时候又出现了新的问题，如果_min和_second都出栈之后，_min和_second该如何更新？

假设有栈为8,10,6,2,9

_min为2，_second为6.当2出栈之后_min更新为_second,但是_second该如何更新？

思路3

既然需要不断的更新最小值，那就把所有的最小值给保存起来。

解决方案一：

每次push()和pop()时将数据和最小值同时压入。

假设有一个栈 8 7 10 6 2 2 9

则存储的结构为：

入栈时的操作：

1）如果栈为空或者入栈的元素d比当前栈的最小元素_s.top()._min小，则_min=d;

2）如果入栈元素d比当前栈的元素大于或者等于则直接将当前栈的最小值_s.top()._min赋给_min。

出栈操作：直接出栈

返回Min则 ：当栈不为空时，返回当前栈顶元素的_min即_s.top()._min。

实现代码：

//节点结构
template<class T>
struct Node
{
public:
	T _data;//数据域
	T _min;//当前最小值
};

//栈的实现
template<class T>
class Stack
{
public:
	void Push(const T& d)
	{
		Node<T> Data;
		Data._data = d;//不能将d直接入栈，因为栈为一个结构体栈

		if (_s.empty() || d < _s.top()._min)//如果栈为空或者入栈元素小于当前栈的最小值
		{
			Data._min = d;
		}
		else//入栈元素大于等于当前栈的最小值
		{
			Data._min = _s.top()._min;
		}

		_s.push(Data);//入栈
	}

	void Pop()
	{
		_s.pop();
	}
	T& Min()
	{
		if (_s.empty())
		{
			throw exception("栈为空");
		}
		return _s.top()._min;
	}
private:
	stack<Node<T>> _s;
};

总结：代码实现起来比较容易简洁，好理解可读性比较强，但是对于重复比较多的栈的元素的存取则比较浪费空间，

因为每次入栈和出栈时，都相当于入栈两次。

例如：8、6、6、6、9、5、5、5、5、10、2、2、11、2、2

解决方案二：

使用两个栈来实现。s1实现栈的push和pop，s2栈用于存储在push和pop过程中的最小值

比如有一组数要入栈： 8,10,6,2,9

S1： 8,10,6,2,9

S2： 8 6 2

每次入栈时，都会和S2.top 比较，如果小于S2.top 则会同时入S1和S2栈。

即到栈顶9时，最小值是2， 如果S1栈9出，和S2.top比较，如果大于S2.top，则S2不做任何操作，如果等于S2.top， 则S2.pop（）；

比如S1的2出栈时，2 == S2.top(), 然后S2.pop();这样就节省了很多空间。

但是上述方法还有问题：

比如数据

S1：8 7 10 6 2 2 2 9 这时

S2：8  7 6 2

当S1中2出栈时，S2中的2也会出栈，这样从S2中读取到的最小值就是6，但是明显错了。

解决方案：

既然栈中可能存在多个重复的最小值_min，解决方法有两种：

方法一：S2中每个元素添加一个计数器。这样当连续3次2出栈，S2中的2才出栈。

方法二：S2中入栈的时候将<=S2.top的元素统统入栈，即S2为8,7,6,2,2,2.

实现代码（计数器）：

template<typename T>
struct DataCount
{
public:
	DataCount(const T & d)
		:_data(d)
		,_count(1)
	{}
public:
	T _data;
	int _count;
};

template<typename T>
class Stack
{
	//拷贝构造、赋值、均使用默认的即可，因为拷贝构造和赋值的时候调用的是stack的，不存在浅拷贝
public:
	void Push(const T &d)
	{
		_s.push(d);//d入数据栈

		DataCount<T> tmp(d);//由于_min为DataCount的栈，所以d不能直接入栈

		if (_min.empty()|| d < _min.top()._data)//如果存放最小的栈为空或者小于
		{
			_min.push(tmp);
		}
		else if (d == _min.top()._data)//入栈的元素等于_min栈的栈顶元素，计数器_count+1;
		{
			_min.top()._count++;
		}
	}

	void Pop()
	{
		if (_s.empty())
		{
			return;
			//throw exception("栈为空");
		}

		//如果数据栈出栈的元素等于_min栈的栈顶元素
		if (_s.top() == _min.top()._data)
		{
			if (_min.top()._count==1)//数据栈中最小的元素只有一个
			{
				_min.pop();
			}
			else//数据栈中存在多个相等的最小元素
			{
				_min.top()._count--;
			}
		}

		//如果数据栈出栈的元素大于_min栈的栈顶元素
		//由于_min栈中存放的都是较小的元素，所以不可能比数据栈要出栈的元素更大
		_s.pop();
	}

	T& Min()
	{
		if (_min.empty())
		{
			//return -1;
			throw exception("栈为空");
		}
		return _min.top()._data;
	}

private:
	stack<T> _s; //存储基本数据的栈
	stack<DataCount<T>> _min; //存储最小值的栈
};

实现代码（重复元素进栈）

template<typename T>
class Stack
{
public:
	void Push(const T &d)
	{
		_s.push(d);//d入数据栈

		if (_min.empty()|| d <= _min.top())//如果存放最小的栈为空或者入栈的元素小于等于_min栈的栈顶元素
		{
			_min.push(d);
		}
	}

	void Pop()
	{
		if (_s.empty())
		{
			return;
			//throw exception("栈为空");
		}

		//如果数据栈出栈的元素等于_min栈的栈顶元素
		if (_s.top() == _min.top())
		{
			_min.pop();
		}

		//如果数据栈出栈的元素大于_min栈的栈顶元素
		//由于_min栈中存放的都是较小的元素，所以不可能比数据栈要出栈的元素更大
		_s.pop();
	}

	T& Min()
	{
		if (_min.empty())
		{
			//return -1;
			throw exception("栈为空");
		}
		return _min.top();
	}

private:
	stack<T> _s; //存储基本数据的栈
	stack<T> _min; //存储最小值的栈
};

比较：

方法一：

优点：适用于大量的重复的较小值的存储

缺点：在一般场景下空间浪费比较大，因为S2中每个元素添加一个计数器。

例如：8、6、6、6、9、5、5、5、5、10、2、2、11、2、2

使用计数器比较节省空间。

方法二：

优点：在一般场下比较节省空间。

缺点：对于大量的重复的较小值得存储比较浪费

例如：8、6、5、12、9、2、11、7

测试代码：  

void test()
{
	Stack<int> s1;
	s1.Push(10);
	s1.Push(11);
	s1.Push(6);
	s1.Push(2);
	s1.Push(2);
	s1.Push(2);
	s1.Push(12);
	Stack<int> s3(s1);
	Stack<int> s2;
	s2 = s1;
	try
	{
		cout << s1.Min() << endl;
		s1.Pop();
		cout << s1.Min() << endl;
		s1.Pop();
		cout << s1.Min() << endl;
		s1.Pop();
		cout << s1.Min() << endl;
		s1.Pop();
		cout << s1.Min() << endl;
		s1.Pop();
		cout << s1.Min() << endl;
		s1.Pop();
		cout << s1.Min() << endl;
		s1.Pop();
		cout << s1.Min() << endl;
		s1.Pop();
		cout << s1.Min() << endl;
		s1.Pop();
		cout << s1.Min() << endl;
	}
	catch (...)
	{
		cout << "栈为空" << endl;
	}

	try
	{
		cout << s2.Min() << endl;
		s2.Pop();
		cout << s2.Min() << endl;
		s2.Pop();
		cout << s2.Min() << endl;
		s2.Pop();
		cout << s2.Min() << endl;
		s2.Pop();
		cout << s2.Min() << endl;
		s2.Pop();
		cout << s2.Min() << endl;
		s2.Pop();
		cout << s2.Min() << endl;
		s2.Pop();
		cout << s2.Min() << endl;
	}
	catch (...)
	{
		cout << "栈为空" << endl;
	}
}
int main()
{
	test();
	getchar();
	return 0;
}