数据结构学习笔记 --- 栈、队列 （习题）

1. 引言

本文主要讲解栈和队列的一些常见的面试题。

2.一些常见的面试题

2.1 题目：输入两个整数序列。其中一个序列表示栈的push顺序，判断另一个序列有没有可能是对应的pop顺序。为了简单起见，我们假设push序列的任意两个整数都是不相等的。

比如输入的push序列是1、2、3、4、5，那么4、5、3、2、1就有可能是一个pop系列。因为可以有如下的push和pop序列：push 1，push 2，push 3，push 4，pop，push 5，pop，pop，pop，pop，这样得到的pop序列就是4、5、3、2、1。但序列4、3、5、1、2就不可能是push序列1、2、3、4、5的pop序列。

//栈的push、pop序列
#include<iostream>
#include<stack>
#include<assert.h>
const int SIZE=5;                  //定义长度
using namespace std;

bool DecidePushPopSequence(
int* push_sequence ,
int* pop_sequence,
int length
)
{
/*
参数合法性判断
*/
assert(push_sequence && pop_sequence && length>0);

stack<int> aid_stack;

int i=0;        //扫描入栈序列
int j=0;        //扫描出栈序列

/*
把push_sequence中的元素入栈，并在每次遍历时，检索pop_sequence中可以pop的元素。
如果循环结束，而stack中还有元素，就说明pop_sequence序列不是pop序列。
*/
while(i<length)
{
cout<<"push "<<push_sequence[i]<<endl;         //测试
aid_stack.push(push_sequence[i]);
i++;

while (!aid_stack.empty() && aid_stack.top() == pop_sequence[j])
{
cout<<"pop "<<pop_sequence[j]<<endl;      //测试
j++;
aid_stack.pop();
}
}

if (i==length && j==length)
{
return true;
}
else
return false;
}

int main(void){
int Spush[SIZE],Spop[SIZE];
for(int i=0;i<SIZE;i++)
cin>>Spush[i];
for(int i=0;i<SIZE;i++)
cin>>Spop[i];
if(DecidePushPopSequence(Spush,Spop,SIZE)) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
}

2.2 题目：给栈中的元素排序，要求栈顶元素最小，不得借助其他数据结构，算法的空间复杂度为O(1)

分析：使用递归函数求解，递归函数每次将当前栈的最大元素移至栈底。

参考：http://s.sousb.com/2011/04/10/%E7%BB%99%E6%A0%88%E6%8E%92%E5%BA%8F/

http://johnwaken.is-programmer.com/posts/14471
http://dongdong1314.blog.51cto.com/389953/413788

#include<iostream>
#include<stack>
#include<assert.h>
const int SIZE=5;                  //定义长度
using namespace std;
#define TESTMETHOD

#ifdef TESTMETHOD1  // method 1
void ReverseStack(std::stack<int>& stack)
{
if (stack.size() == 0)
return;
int top = stack.top();
stack.pop();

ReverseStack(stack);

if (0 == stack.size())
{
stack.push(top);
return;
}

int top2 = stack.top();
stack.pop();

ReverseStack(stack);
stack.push(top);
ReverseStack(stack);
stack.push(top2);
}

int main()
{
stack<int> rev_stack;
for(int i=0;i<SIZE;i++)
{
rev_stack.push(i);
}
ReverseStack(rev_stack);

for(int i=0;i<SIZE;i++)
{
cout << rev_stack.top() << " " << endl;
rev_stack.pop();
}

return 0;
}
#else  // method 2
void ReverseStack(
std::stack<int>& s,         //当前考虑的子栈
int pop_size,                 //剩余出栈元素个数
int stack_size,               //子栈大小
int& top_element              //栈顶元素
);

void ReverseMain(std::stack<int>& s)
{
/*
每次将s栈顶上拥有stack_size个元素的子栈栈顶元素
沉到底部
*/
int stack_size=s.size();
for (; stack_size>0;stack_size--)
{
int top;
ReverseStack(s,stack_size,stack_size,top);
}
}

/*
不依赖辅助栈，每次将最顶上的元素沉到拥有stack_size个元素的子栈栈底

*/
void ReverseStack(
std::stack<int>& s,         //当前考虑的子栈
int pop_size,                 //剩余出栈元素个数
int stack_size,               //子栈大小
int& top_element              //栈顶元素
)
{

//剩余出栈元素个数等于当前考虑的栈大小
//将栈顶元素保存到参数中
if (pop_size == stack_size)
{
top_element = s.top();
s.pop();
pop_size--;
}

//当前考虑的栈已经为空
if (pop_size == 0)
{
s.push(top_element);
return;
}

int top = s.top();
s.pop();
pop_size--;

ReverseStack(s,pop_size,stack_size,top_element);

//返回后，恢复栈中的元素
s.push(top);

}

int main(void){

stack<int> rev_stack;
for(int i=0;i<SIZE;i++)
{
rev_stack.push(i);
}
ReverseMain(rev_stack);

for(int i=0;i<SIZE;i++)
{
cout << rev_stack.top() << " " << endl;
rev_stack.pop();
}

return 0;
}
#endif