数据结构 --- 栈和队列

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(
d9f4
))
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.  }