<剑指offer>之栈和队列所有题目

最新推荐文章于 2021-10-15 16:56:30 发布

luno1

最新推荐文章于 2021-10-15 16:56:30 发布

阅读量2.3k

点赞数

分类专栏：数据结构|算法文章标签： delete 测试数据结构扩展 null 微软

本文链接：https://blog.csdn.net/luno1/article/details/7980673

版权

数据结构|算法专栏收录该内容

11 篇文章 0 订阅

订阅专栏

【引言】stack和queue的题目不太多，而且几道题目大概思路要么是构造辅助stack或者queue，要么是根据stack的FILO和queue的FIFO特性下手有一定的技巧性

【题目7】用两个队列实现栈

用两个栈实现队列。队列声明如下，请实现它的两个函数append_tail和delete_head在队列的队尾添加数据和删除队头

template<typename T>
class Queue_by_stack
{
public:
	Queue_by_stack(){};
	~Queue_by_stack(){};

	void append_tail(const T& node);
	T delete_head();
protected:
private:
	stack<T> stack1;
	stack<T> stack2;
};

分析：队列的特性是先进后出，比如对于1,2,3,4序列来说，首先将序列压入栈（stack1和stack2随便选一个），要实现delete_head的话，不能对stack1进行pop,因为这时stack1的top值是4，我们要删除的是1，注意这时候stack2还没有利用，如果我将stack1里的数据都逐个pop,push进去stack2，对于stack2；来说，那不就正好相当于原序列吗？实现delete_head的话只需对stack2进行pop就行了，append_tail的话只需往空的stack1里面push就行了。代码实现如下

【代码】

#include <iostream>
#include <stack>
using namespace std;

template<typename T>
class Queue_by_stack
{
public:
	Queue_by_stack(){};
	~Queue_by_stack(){};

	void append_tail(const T& node);
	T delete_head();
protected:
private:
	stack<T> stack1;
	stack<T> stack2;
};


template<typename T>
T Queue_by_stack<T>::delete_head()
{
	T tmp;
	if (stack2.empty())
	{
		while (!stack1.empty())
		{
			tmp = stack1.top();
			stack2.push(tmp);
			stack1.pop();
		}
	}
	if (stack2.empty())
	{
		return -1;
	}
	tmp = stack2.top();
	stack2.pop();
	return tmp;		
}

template<typename T>
void Queue_by_stack<T>::append_tail( const T& node )
{
	stack1.push(node);
}

【测试】

int main()
{
#if 0
	Queue_by_stack<char> my_queue;
	my_queue.append_tail('a');
	my_queue.append_tail('b');
	my_queue.append_tail('c');

	my_queue.delete_head();
	my_queue.delete_head();
	my_queue.delete_head();
	my_queue.delete_head();
	my_queue.append_tail('d');
	my_queue.append_tail('e');
	my_queue.delete_head();
#endif
}

【扩展】使用两个队列实现一个栈

这个栈的声明如下：

template<typename T>
class Stack_by_queue
{
public:
	Stack_by_queue(){};
	~Stack_by_queue(){};

	void append_tail(const T& node);
	T delete_head();
protected:
private:
	queue<T> queue1;
	queue<T> queue2;
};

分析：栈的特性是先进后出，举一个序列1,2,3,4来说，我们试着往一个queue1里面push进去，这时候queue1的队头是1，队尾是4，这时候要实现delete_head的话，对应的栈应该删除4，对于queue1的队尾，前面的1,2,3，都是不需要的。

实现dalete_head解决方法就是，依次弹出1,2,3并且压入queue2中，queue1里面只保存4，这时候要delete_head的话，对queue1进行pop操作就行了，然后queue1为空（注意这个状态）,然后我要继续delete_head,这个时候也是按照上面的思路，将queue2的1,2依次弹出，压入queue1里面，知道剩下最后一个队尾元素3，将它pop掉就行了！这时候的状态是queue1不为空，queue2为空。

实现append_tail的话也容易。注意上面的删除头以后的两种状态其实可以可以归结为一种，那就是其中一个queue为空，另一个可以为空（这个时候模拟的stack就是空），或者不为空，append_tail来说，只需往非空的queue里面添到队尾就行了，若是都为空，随便选一个即可

【实现】

#include <queue>
using namespace std;
template<typename T>
class Stack_by_queue
{
public:
	Stack_by_queue(){};
	~Stack_by_queue(){};

	void append_tail(const T& node);
	T delete_head();
protected:
private:
	queue<T> queue1;
	queue<T> queue2;
};

//保证在所有的过程中，至少队列有一个是空的
template<typename T>
T Stack_by_queue<T>::delete_head()
{
	T tmp;
	if(queue1.empty() && !queue2.empty())
	{
		//2->1
		
		if (queue2.size() < 1)
		{
			return -1;
		}
		while(queue2.size() != 1)
		{
			tmp = queue2.front();
			queue2.pop();
			queue1.push(tmp);
		}
		tmp = queue2.front();
		queue2.pop();
		return tmp;
	}
	if (!queue1.empty() && queue2.empty())
	{
		//1->2
		T tmp;
		if (queue1.size() < 1)
		{
			return -1;
		}
		while(queue1.size() != 1)
		{
			tmp = queue1.front();
			queue1.pop();
			queue2.push(tmp);
		}
		tmp = queue1.front();
		queue1.pop();
		return tmp;

	}
	else
		return -1;	
}

template<typename T>
void Stack_by_queue<T>::append_tail( const T& node )
{
	//保证有一队列为空，若全为空，则队空,任选一个队列就行
	if (queue1.empty() && !queue2.empty())
		queue2.push(node);
	if (!queue1.empty() && queue2.empty())
		queue1.push(node);
	if (queue1.empty() && queue2.empty())
		queue1.push(node);
	else 
		return;
}

【测试】

int main()
{
#if 1


	Stack_by_queue<char> my_stack;
	my_stack.append_tail('a');
	my_stack.append_tail('b');
	my_stack.append_tail('c');
	my_stack.delete_head();
	my_stack.delete_head();
	my_stack.delete_head();
	my_stack.delete_head();
	my_stack.append_tail('d');
	my_stack.append_tail('e');
	my_stack.delete_head();
	my_stack.append_tail('f');
#endif
}

【题目21】包含min函数的栈

描述：定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的函数。在该栈中，调用min,push,pop的时间复杂度都是O(1)

思路：首先是一个栈，这个栈已经是最常见的那种，我们需要改造它使它能够在O(1)时间内返回最小元素，刚开始的思路是往栈里面添加一个元素放在stack的顶部，表示当前栈里面的最小元素，如果压入的元素比它小，那么更新它，并且将它pop出来，放在一个临时值里面，将刚才要压入的序列元素push进去栈，再将最小值压进去，看上去可行。但这样有问题，比如说我对栈pop操作，我需要将栈顶的最小元素弹出，存起来，然后将真正的栈顶元素弹出，这个时候我要是再把刚才保存的栈顶元素压入原栈，就不一定对了，因为删除一个元素以后，最小元素也要更新，如何得到次小元素的值呢？明显我们需要保存次小，再次小。。。的值，为此我们使用两个栈，一个是普通的数据栈，data_stack,和另外一个auxi_stack辅助栈，首先在空的时候都压入两个栈，然后对于压入的序列，比较这个元素和辅助栈栈顶元素，如果小于这个栈顶那么在压入数据栈的时候也压入辅助站，否则，将辅助栈的顶部元素再次压入一次，这样保证了两个栈的大小相等，这样才能在pop的时候同步，否则我在调用min以后更新候判断就比较麻烦。

这样需要的空间就是两个相等的栈

【代码】

template <typename T>
class  min_stack
{
public:
	min_stack(){};
	~min_stack(){};

	T my_min();
	void my_push(const T& data);
	void my_pop();
protected:
private:
	stack<T> data_stack;
	stack<T> auxi_stack;
};

template <typename T>
void min_stack<T>::my_pop()
{
	if (auxi_stack.empty() && data_stack.empty())
		return;
	else
	{
		auxi_stack.pop();
		data_stack.pop();
	}
}

template <typename T>
void min_stack<T>::my_push(const T& data)
{
	data_stack.push(data);
	if(auxi_stack.empty() || data < auxi_stack.top())
		auxi_stack.push(data);
	else
		auxi_stack.push(auxi_stack.top());

}

template <typename T>
T min_stack<T>::my_min()
{
	if(!auxi_stack.empty())
		return auxi_stack.top();
	else
		return -1;
}

【测试】

int main()
{
	min_stack<int> my_min_stack;
	my_min_stack.my_push(3);
	my_min_stack.my_push(2);
	my_min_stack.my_push(1);
	my_min_stack.my_push(8);
	my_min_stack.my_min();
	my_min_stack.my_pop();
	my_min_stack.my_min();
	my_min_stack.my_push(2);
	my_min_stack.my_push(1);
	my_min_stack.my_min();


}

【题目22】判断压入弹出顺序问题

题目描述：

对于两个序列，第一个表示栈的压入顺序，第二个序列表示栈的弹出顺序，判断下第二个序列是否是第一个序列的弹出顺序。假设原数序列元素都不相等。比如对于原始序列1,2,3,4,5来说，序列4,5,1,2,3就是它的一个弹出序列，对原始序列执行的操作时push,push，push,push,pop,push,pop,pop,pop,pop

思路：对于这种问题需要慢慢分析，对于4,5,1,2,3来说，要首先弹出一个4，必须将原始序列中4之前的元素都压栈，然后弹出4，然后看第二个元素5，首先栈顶不是这个5，我们需要在上次压栈改变后原始序列中找，只剩第五个元素5，压栈，弹出，第三个元素3，栈顶就是，弹出，依次这样。。。如果碰见在原始序列中找不到并且栈顶也不是这个元素的情况，无论如何也不能是原始序列，这个元素肯定在栈里面，非栈顶。so,代码如下。。

【代码】

#include <stack>
using namespace std;

//思路：遍历第二个序列，对于序列的每个元素，首先看这个元素在不在栈顶，在的话弹出；
//不在的话遍历第一个序列，一边遍历一边将第一个序列元素压栈,如果第一个序列没有，则证明则第二个序列的这个元素已经压进去栈了
bool is_pop_order(const int* to_push, const int* to_pop, int len)
{
	if(to_push== NULL || to_pop== NULL || len < 1)
		return false;
	stack<int> tmp_stack;	
	int tmp;
	int i, j;
	for (i = 0, j = 0; i < len; i++)
	{
		tmp = to_pop[i];
		if (!tmp_stack.empty() && tmp == tmp_stack.top())
		{
			tmp_stack.pop();
		}
		else
		{
			while(j < len && tmp != to_push[j])
			{
				tmp_stack.push(to_push[j]);
				++j;
			}
			if (j == len)//第一个序列里面没有，失败
			{
				return false;
			}
			else//在第一个序列的j个位置
			{
				++j;
			}
		}
	}
	return true;
}

【测试】

int main()
{

	int a[] = {1,2,3,4,5};
	int	b[] = {4,5,3,2,1};
	int c[] = {4,3,5,1,2};
	int d[1] = {5};
	int e[1] = {5};
	bool res1 = is_pop_order(a, b, sizeof(a)/sizeof(a[0]));
	bool res2 = is_pop_order(a, c, sizeof(a)/sizeof(a[0]));
	bool res3 = is_pop_order(d,e,1);
}