Stack和quque

102. 二叉树的层序遍历 - 力扣（LeetCode）

如图：层序遍历即一层一层遍历，从左到右。

先遍历第一层，把第一层的节点放到队列里面，levesize=q.size()，即代表队列里面有多少个值。

然后现在把队里里面的值清空，放到vector里面(每一层的值都放一个vectot里面）。再把第二层的节点传到队列里面。levesize也根据队列的size产生变化：

以此类推,最终效果为：

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector> levelOrder(TreeNode* root) {
    queue q;//套用树模版来个队列
       vector> vv;//最后把遍历完的数据放到vv里
       int levesize=0;
    if(root) q.push(root);
    levesize=1;
  

    while(!q.empty())//当队列不为空时
    {  vector v;

      while(levesize--)
      {
        TreeNode* Front=q.front();
        q.pop(); 
        v.push_back(Front->val);
         if(Front->left) q.push(Front->left);
         if(Front->right) q.push(Front->right);
      }
      levesize=q.size();

  vv.push_back(v);
    }
        
        return vv;
    
    }
};

150. 逆波兰表达式求值 - 力扣（LeetCode）

这道题实际上就用后缀和去实现运算：

平时我们的运算都是中缀运算，如1+2*3，1+2是不能先算的，因为我们不能确定后面操作符，后面操作符的优先级如果比“+”优先级大那么1+2就不能 先运算，应该先运算2*3，然后得到的结构再去+1.

列如我们有一个这样的式子：((2 + 1) * 3) = 9。如果用后缀运算，就是把

((2 + 1) * 3) = 9变换成2  1 + 3  *。

至于怎么变成后缀的，这道题已经帮我们编好了，我们只需要把它编好的数据入栈就行了：

 然后后进先出，先从操作数里取两个数出来，为什么取两个出来呢？因为一个操作符肯定需要两个操作数进行操作。然后操作完之后再入栈：

 代码：

class Solution {
public:
    int evalRPN(vector& tokens) {


stack  st;


for(auto str:tokens)
{
    if( str=="+"
        ||str=="-"
        ||str=="*"
        ||str=="/"
      )
         {
             int right=st.top();
             st.pop();
             int left=st.top();
             st.pop();
             switch(str[0])
             {
                  case '+':
                  st.push(left+right);
                  break;
                  case '-':
                  st.push(left-right);
                  break;
                  case '*':
                  st.push(left*right);
                  break;
                  case '/':
                  st.push(left/right);
                  break;
             }
         }
         else
         {
             st.push(stoi(str));
         }

}
return st.top();
    }
};

模拟实现一下栈，然后测一下上面这个逆波兰表达式：

首先把写一个模版，这个模版里面我们除了放T这个类型之外还要再放个参数：Container，这个参数就是我们可以把vector,list等其他容易作为这个栈的底层，这个栈可以用其他容器的push_back,pop_back,size()等函数。

 写一下函数的定义：

 main函数把逆波兰那道题的代码复制过来：

然后写一个测试用例：

 传一个vector作为底层：

运行：

 传list作为底层：

 运行：

写一段如下代码验证一下deque sort和vector sort占用栈帧情况对比：

void test2()
{
    srand((size_t)time(0));
    const size_t  N = 100000;
    vector v;
    deque dq;
    v.reserve(N);
  
    for (size_t i = 0; i < N; i++)
    {
        auto e = rand;
        v.push_back((int)e);
        dq.push_back((int)e);
    }

    int begin1 = clock();
    sort(v.begin(), v.end());
    int end1 = clock();

    int begin2 = clock();
    sort(dq.begin(), dq.end());
    int end2 = clock();


    cout << "vector sort:" << end1 - begin1 << endl;
    cout << "deque sort:" << end2 - begin2 << endl;
}

 然后再把deque给vector来跑

void test2()
{
    srand((size_t)time(0));
    const size_t  N = 100000;
    vector v;
    deque dq;
    v.reserve(N);

    for (size_t i = 0; i < N; i++)
    {
        auto e = rand;
        v.push_back((int)e);
        dq.push_back((int)e);
    }

    int begin1 = clock();
    sort(v.begin(), v.end());
    int end1 = clock();

    int begin2 = clock();
    v.assign(dq.begin(), dq.end());
    sort(v.begin(), v.end());

    int end2 = clock();


    cout << "vector sort:" << end1 - begin1 << endl;
    cout << "deque sort:" << end2 - begin2 << endl;
}

 

queue.h

#pragma once
#include
#include
namespace bitt
{	template>
	class queue
	{
	public:

	

		void push(const T& x)
		{
			_con.push_back(x);
		}
	
		void pop()
		{
			_con.pop_front();
		}
        const T& front()
		{
			return _con.front();
		}
		const T& back()
		{
			return _con.back();
		}
	
		bool empty()
		{
			return _con.empty();
		}
	

		size_t size()
		{
			return _con.size();
		}


	private:
		Container _con;
	};



}

main

void test_queue()
{
    bitt:: queue q;
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);
    q.push(5);
   while(!q.empty())
    {
       cout << q.front()<<" ";
       q.pop();
    }
   cout << endl;
}

int main()
{

test_queue();
}