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

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