数据结构 --- 栈和队列

1. 用两个栈来实现队列

思路：栈是先进后出，而队列是先进先出。可以这样设计，一个栈用于入队列操作，设为Stack1，另一个栈用于出队列操作，设为Stack2。入队列可以在常数时间内完成，即Stack1的入栈操作。而出队列时，若Stack2的元素不为空，Stack2执行出栈操作，相当于出队列。若为空，则将Stack1的元素一个个出栈，压入Stack2中，然后Stack2再执行一次出栈操作。

 1. template<typename T>  
2.  class SQueue  
3.  {  
4.  public:  
5.      SQueue() {}  
6.      ~SQueue() {}  
7.      void PushBack(const T &x);  
8.      void PopFront();  
9.  private:  
10.     stack<T> m_stack1;  
11.     stack<T> m_stack2;  
12. };
13. 14. template<typename T>   
15. void SQueue<T>::PushBack(const T &x)  
16. {  
17.     m_stack1.push(x);  
18. }  
19.   
20. template<typename T>   
21. void SQueue<T>::PopFront()  
22. {  
23.     if(m_stack2.size() == 0)   
24.     {  
25.         while(m_stack1.size() > 0)  
26.         {  
27.             m_stack2.push(m_stack1.top());  
28.             m_stack1.pop();  
29.         }  
30.     }  
31.     if(m_stack2.size() > 0)  
32.         m_stack2.pop();
33.    return；
33. } 

2. 用两个队列来实现栈

思路：稍微复杂了一点，容易想到的就是这种设计。出栈时，检查两个队列，找到元素个数不为空的那个队列，执行出队列操作。如果是压栈操作，找到元素为空队列Queue1，执行入队列操作，然后Queue2执行出队列操作，出来的元素依次进入Queue1。(入栈时，两个队列来回折腾) —- 每次压栈，都有一个队列为空。

1.  template <typename T>  
2.  class QStack  
3.  {  
4.  public:  
5.      QStack() {}  
6.      ~QStack() {}  
7.      void PushBack(const T &x);  
8.      void PopBack();  
9.  private:  
10.     queue<T> m_queue1;  
11.     queue<T> m_queue2;  
12. };  
13.   
14. template <typename T>  
15. void QStack<T>::PushBack(const T &x)  
16. {  
17.     if(m_queue1.size() == 0)  
18.     {  
19.         m_queue1.push(x);  
20.         while(m_queue2.size() > 0)  
21.         {  
22.             m_queue1.push(m_queue2.front());  
23.             m_queue2.pop();  
24.         }  
25.     }  
26.     else  
27.     {  
28.         m_queue2.push(x);  
29.         while(m_queue1.size() > 0)  
30.         {  
31.             m_queue2.push(m_queue1.front());  
32.             m_queue1.pop();  
33.         }  
34.     }  
35. }  
36. template <typename T>  
37. void QStack<T>::PopBack()  
38. {  
39.     if(m_queue1.size() > 0)  
40.         m_queue1.pop();  
41.     else if(m_queue2.size() > 0)  
42.         m_queue2.pop();  
43. }

3. 跳台阶问题。具体描述，一个台阶总共有n级，如果一次可以跳1级，也可以跳2级。求总共有多少总跳法，并分析算法的时间杂度。

思路：简单分析一下，这道题不难。假设f(n)为问题的解，从后往前推，最后一跳有两种情况，一是跳1级，二是跳2级，可以得出这个式子 f(n) = f(n-1) + f(n-2)，其中f(1)=1，f(2)=2。递归实现如下，当然也可以用迭代。

1.  //函数功能 ： 跳台阶问题  
2.  //函数参数 ： n为台阶个数  
3.  //返回值 ：   总的跳法  
4.  unsigned JumpSteps_Solution1(unsigned n)  
5.  {  
6.      if(n <= 2)  
7.          return n;  
8.      else   
9.          return JumpSteps_Solution1(n - 1) + JumpSteps_Solution1(n - 2);  
10. }  
11.   
12. unsigned JumpSteps_Solution2(unsigned n)  
13. {  
14.     if(n <= 2)  
15.         return n;  
16.   
17.     unsigned sum = 0;  
18.     unsigned f1 = 1, f2 = 2;  
19.     for(unsigned i =3; i <= n; i++)  
20.     {  
21.         sum = f1 + f2; //f(n) = f(n-2) + f(n-1)  
22.         f1 = f2;       //f(n-2) = f(n-1)  
23.         f2 = sum;      //f(n-1) = f(n)  
24.     }  
25.     return sum;  
26. }   

4. 栈的push、pop序列。具体描述，输入两个整数序列。其中一个序列表示栈的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序列的当前元素，则将这个元素压栈；如果相等，则检查push序列的下一个元素，同时pop序列的当前元素往前移1个。最后将辅助栈中的元素退栈，并与pop序列进行比较。最后辅助栈的元素为空，并且pop序列的当前位置为最后元素的下一个位置，则这个序列是pop序列。

1.  //函数功能 ： 栈的push、pop序列  
2.  //函数参数 ： pPush为push序列，pPop为pop序列，nLength为序列长度  
3.  //返回值 ：   是否成立  
4.  bool IsPossiblePopOrder(const int* pPush, const int* pPop, int nLength)  
5.  {  
6.      stack<int> helpStack; //定义一个辅助栈  
7.      int i = 0, j = 0;  
8.      //将push序列的元素压栈  
9.      while(i < nLength)  
10.     {  
11.         if(pPush[i] == pPop[j]) //相等，pop序列往前移动1  
12.             j++;  
13.         else  
14.             helpStack.push(pPush[i]);  
15.         i++;  
16.     }  
17.     //将栈中剩余元素退栈  
18.     while(!helpStack.empty())  
19.     {  
20.         if(helpStack.top() == pPop[j])  
21.         {  
22.             helpStack.pop();  
23.             j++;  
24.         }  
25.         else  
26.             break;  
27.     }  
28.     return helpStack.empty() ? true : false;  
29. }  

5. 颠倒栈。用递归颠倒一个栈。例如输入栈{1, 2, 3, 4, 5}，1在栈顶。颠倒之后的栈为{5, 4, 3, 2, 1}，5处在栈顶。

思路：这道题纯粹是为了加深递归的理解。用两个递归来做。

1.  //函数功能 ： 颠倒栈  
2.  //函数参数 ： 要颠倒的栈  
3.  //返回值 ：   无  
4.  template<typename T>  
5.  void ReverseStack(stack<T> &srcStack)  
6.  {  
7.      if(!srcStack.empty())  
8.      {  
9.          T tmp = srcStack.top();  
10.         srcStack.pop();  
11.         ReverseStack(srcStack);  
12.         AddtoStackBottom(srcStack, tmp); //放到栈底  
13.     }  
14. }  
15. template<typename T>  
16. void AddtoStackBottom(stack<T> &srcStack, T x)  
17. {  
18.     if(srcStack.empty())  
19.     {  
20.         srcStack.push(x);  
21.     }  
22.     else  
23.     {  
24.         T tmp = srcStack.top();  
25.         srcStack.pop();  
26.         AddtoStackBottom(srcStack, x);  
27.         srcStack.push(tmp);  
28.     }  
29. }  

6. 设计包含min函数的栈。定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。要求函数min、push以及pop的时间复杂度都是O(1)。

思路：利用双栈来做。一个栈用于正常的入栈退栈，称为Stack1，另外一个用于保存栈的最小元素，称为Stack2。Stack1入栈时，将入栈元素与Stack2的栈顶元素比较，如果小于栈顶元素，则两个栈同时执行入栈操作。Stack1退栈时，如果退栈元素与Stack2的栈顶元素相等，则两个栈同时执行出栈操作。下面是一个简单的实现。

1.  template<class T>  
2.  class MinStack  
3.  {  
4.  public:  
5.      MinStack();  
6.      ~MinStack();  
7.      bool Empty() const; //判断栈是否为空  
8.      void Push(T value); //压栈  
9.      void Pop();         //退栈  
10.     T& Top();  
11.     const T& Top() const;  
12.     const T& Min() const;  
13. private:  
14.     stack<T> m_comStack; //正常栈  
15.     stack<T> m_minStack; //最小栈  
16. };  
17. template<class T>  
18. MinStack<T>::MinStack()  
19. {  
20. }  
21. template<class T>  
22. MinStack<T>::~MinStack()  
23. {  
24. }  
25. template<class T>  
26. bool MinStack<T>::Empty() const  
27. {  
28.     return m_comStack.empty();  
29. }  
30. template<class T>  
31. void MinStack<T>::Push(T value)  
32. {  
33.     if(m_minStack.empty() || value <= m_minStack.top())  
34.         m_minStack.push(value);  
35.     m_comStack.push(value);  
36. }  
37. template<class T>  
38. void MinStack<T>::Pop()  
39. {  
40.     if(m_minStack.top() == m_comStack.top())  
41.         m_minStack.pop();  
42.     m_comStack.pop();  
43. }  
44. template<class T>  
45. const T& MinStack<T>::Min() const  
46. {  
47.     return m_minStack.top();  
48. }  
49. template<class T>  
50. T& MinStack<T>::Top()  
51. {  
52.     m_comStack.top();  
53. }  
54. template<class T>  
55. const T& MinStack<T>::Top() const  
56. {  
57.     m_comStack.top();  
58. }   

7. 多进制输出

 1. string multiBaseOutput(int num, int base)
2.  {
3.      string digitChar = “0123456789ABCDEF”;
4.      string numstr = “ “;
5.      stack<char> stk;
6.      
7.      do{
8.          stk.push(digitChar[num % base]);
9.          num /= base;
10.     }while(num != 0);
11.     
12.     while(!stk.empty())
13.     {
14.         numstr += stk.top();
15.         stk.pop();
16.     }
17.     return numstr;
18.  }

---