Day-02-栈、队列、堆 Leetcode-225, 231, 155, 224, 215, 295 POJ-1363

最新推荐文章于 2019-10-11 02:24:53 发布
最新推荐文章于 2019-10-11 02:24:53 发布
阅读量121 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/lihello/p/11520849.html
版权

例一：LeetCode225

1747417-20190914235721277-2139901375.png
1747417-20190914235726330-318327627.png

#include <iostream>
#include <queue>
using namespace std;
class  Mystack {
public:
       Mystack() {
       }
       void push(int x) {
              queue<int>temp_queue;
              temp_queue.push(x);//将新元素push进临时队列
              while (!_data.empty()) {//将原队列push进临时队列
                      temp_queue.push(_data.front());
                      _data.pop();
              }
              while (!temp_queue.empty()) {//将临时队列push进data队列
                      _data.push(temp_queue.front());
                      temp_queue.pop();
              }
       }
       int pop() {
              int x = _data.front();
              _data.pop();
              return x;
       }
       int top() {
              return _data.front();
       }
       bool empty() {
              return _data.empty();
       }
private:
       queue<int>_data;
};
int main() {
       Mystack S;
       S.push(1);
       S.push(2);
       S.push(3);
       S.push(4);
       printf("%d\n", S.top());
       S.pop();
       printf("%d\n", S.top());
       S.pop();
       printf("%d\n", S.top());
       return 0;
}

例二：LeetCode232

1747417-20190914235758687-831036774.png
1747417-20190914235809056-1440947612.png

#include <iostream>
#include <stack>
using namespace std;
class MyQueue {
public:
       MyQueue() {
       }
       void push(int x) {
              stack <int> temp_stack;
              while (!_data.empty()) {
                      temp_stack.push(_data.top());
                      _data.pop();
              }
              temp_stack.push(x);
              while (!temp_stack.empty()) {
                      _data.push(temp_stack.top());
                      temp_stack.pop();
              }
       }
       int pop() {
              int x = _data.top();
              _data.pop();
              return x;
       }
       int peek() {
              return _data.top();
       }
       bool empty() {
              return _data.empty();
       }
private:
       stack <int> _data;
};
int main() {
       MyQueue Q;
       Q.push(1);
       Q.push(2);
       Q.push(3);
       Q.push(4);
       printf("%d\n", Q.peek());
       Q.pop();
       printf("%d\n", Q.peek());
       return 0;
}

例三：LeetCode155

1747417-20190914235840115-2025628958.png
1747417-20190914235844572-205031774.png

//在栈内找最小值 时间复杂度为O(1)
 
#include <iostream>
#include <stack>
 
class MinStack {
public:
  void push(int x) {
    _data.push(x);
    if (_min.empty()) {
      _min.push(x);
    }
    else {
      if (x > _min.top()) {
        x = _min.top();
      }
      _min.push(x);
    }
  }
 
  void pop() {
    _data.pop();
    _min.pop();
  }
 
  int top() {
    return _data.top();
  }
 
  int getMin() {
    return _min.top();
  }
 
private:
  std::stack<int> _data;
  std::stack<int> _min;
};
 
int main() {
  MinStack minStack;
  minStack.push(-2);
  printf("top = [%d]\n", minStack.top());
  printf("min = [%d]\n\n", minStack.getMin());
 
  minStack.push(0);
  printf("top = [%d]\n", minStack.top());
  printf("min = [%d]\n\n", minStack.getMin());
 
  minStack.push(-5);
  printf("top = [%d]\n", minStack.top());
  printf("min = [%d]\n\n", minStack.getMin());
 
  minStack.pop();
  printf("top = [%d]\n", minStack.top());
  printf("min = [%d]\n\n", minStack.getMin());
 
  return 0;
}

例四：POJ1363

1747417-20190914235934421-2127665856.png
1747417-20190914235939158-721295737.png

#include <stack>
#include <queue>
#include <stdio.h>
using namespace std;
bool check_is_valid_order(queue<int>& order) {
       stack<int> S;
       int n = order.size();
       for (int i = 1; i <= n; i++) {
              S.push(i);
              while (!S.empty() && order.front() == S.top()) {
                      S.pop();
                      order.pop();
              }
       }
       if (!S.empty()) {
              return false;
       }
       return true;
}
int main() {
       int n;
       int train;
       ~scanf("%d", &n);
       while (n) {
              ~scanf("%d", &train);
              while (train) {
                      queue<int>order;
                      order.push(train);
                      for (int i = 1; i < n; i++) {
                             ~scanf("%d", &train);
                             order.push(train);
                      }
                      if (check_is_valid_order(order)) {
                             printf("Yes\n");
                      }
                      else {
                             printf("No\n");
                      }
                      ~scanf("%d", &train);
              }
              printf("\n");
              ~scanf("%d", &n);
       }
       return 0;
}

例五：LeetCode224

1747417-20190915000005059-1851856221.png
1747417-20190915000009885-1268576251.png
1747417-20190915000018645-381083424.png

#include <stdio.h>
#include <string>
#include <stack>
 
class Solution {
public:
  int calculate(std::string s) {
    static const int STATE_BEGINI = 0;
    static const int NUMBER_STATE = 1;
    static const int OPERATION_STATE = 2;
    std::stack<int> number_stack;
    std::stack<char> operation_stack;
    long long number = 0;  // 用 int 通过不了所有测试数据
    int STATE = STATE_BEGINI;
    int computer_flag = 0;
 
    for (int i = 0; i < s.length(); i++) {
      if (s[i] == ' ') {
        continue;
      }
      switch (STATE) {
      case STATE_BEGINI:
        if (s[i] >= '0' && s[i] <= '9') {
          STATE = NUMBER_STATE;
        }
        else {
          STATE = OPERATION_STATE;
        }
        i--;
        break;
      case NUMBER_STATE:
        if (s[i] >= '0' && s[i] <= '9') {
          number = number * 10 + s[i] - '0';
        }
        else {
          number_stack.push(number);
          if (computer_flag == 1) {
            compute(number_stack, operation_stack);
          }
          number = 0;
          i--;
          STATE = OPERATION_STATE;
        }
        break;
      case OPERATION_STATE:
        if (s[i] == '+' || s[i] == '-') {
          operation_stack.push(s[i]);
          computer_flag = 1;
        }
        else if (s[i] == '(') {
          STATE = NUMBER_STATE;
          computer_flag = 0;
        }
        else if (s[i] >= '0' && s[i] <= '9') {
          STATE = NUMBER_STATE;
          i--;
        }
        else if (s[i] == ')') {
          compute(number_stack, operation_stack);
        }
        break;
      }
    }
    if (number != 0) {
      number_stack.push(number);
      compute(number_stack, operation_stack);
    }
    if (number == 0 && number_stack.empty()) {
      return 0;
    }
    return number_stack.top();
  }
private:
  void compute(std::stack<int>& number_stack, std::stack<char>& operation_stack) {
    if (number_stack.size() < 2) {
      return;
    }
    int num2 = number_stack.top();
    number_stack.pop();
    int num1 = number_stack.top();
    number_stack.pop();
    if (operation_stack.top() == '+') {
      number_stack.push(num1 + num2);
    }
    else if (operation_stack.top() == '-') {
      number_stack.push(num1 - num2);
    }
    operation_stack.pop();
  }
};
 
 
int main() {
  std::string s = "1+121 - (14+(5-6) )";
  Solution solve;
  printf("%d\n", solve.calculate(s));
  return 0;
}

例六：LeetCode215

1747417-20190915000044311-1708894682.png
1747417-20190915000049426-96297885.png
1747417-20190915000055017-1414972952.png

//利用最小堆求第K大的数 n*logK
#include <vector>
#include <queue>
#include <cstdio>
class Solution {
public:
       int findKthLargest(std::vector<int>& nums, int k) {
              std::priority_queue <int, std::vector<int>, std::greater<int>> Q;
              for (int i = 0; i < nums.size(); i++) {
                      if (Q.size() < k) {
                             Q.push(nums[i]);
                      }
                      else if (Q.top() < nums[i]) {
                             Q.pop();
                             Q.push(nums[i]);
                      }
              }
              return Q.top();
       }
};
int main() {
       std::vector<int> nums;
       nums.push_back(3);
       nums.push_back(2);
       nums.push_back(1);
       nums.push_back(5);
       nums.push_back(6);
       nums.push_back(4);
       Solution solve;
       printf("%d\n", solve.findKthLargest(nums, 2));
       return 0;
}

例七：LeetCode295

1747417-20190915000130565-1357337624.png
1747417-20190915000136019-2101969319.png
1747417-20190915000144240-2095764026.png
1747417-20190915000148807-1259715778.png
1747417-20190915000153203-610615344.png
1747417-20190915000157911-159763483.png
1747417-20190915000202525-1904100410.png

/*设计一个数据结构，动态维护一组数据，且支持如下操作
1、添加元素
2、返回数据的中位数
*/
#include <stdio.h>
#include <queue>
class MedinFinder {
public:
       MedinFinder() {}
       void addNum(int num) {
              if (big_queue.empty()) {
                      big_queue.push(num);
                      return;
              }
              if (big_queue.size() == small_queue.size()) {
                      if (num < big_queue.top()) {
                             big_queue.push(num);
                      }
                      else {
                             small_queue.push(num);
                      }
              }
              else if (big_queue.size() > small_queue.size()) {
                      if (num > big_queue.top()) {
                             small_queue.push(num);
                      }
                      else {
                             small_queue.push(big_queue.top());
                             big_queue.pop();
                             big_queue.push(num);
                      }
              }
              else if (big_queue.size() < small_queue.size()) {
                      if (num < small_queue.top()) {
                             big_queue.push(num);
                      }
                      else {
                             big_queue.push(small_queue.top());
                             small_queue.pop();
                             small_queue.push(num);
                      }
              }
       }
       double findMedian() {
              if (big_queue.size() == small_queue.size()) {
                      return (big_queue.top() + small_queue.top()) / 2;
              }
              else if (big_queue.size() > small_queue.size()) {
                      return big_queue.top();
              }
              return small_queue.top();
       }
private:
       std::priority_queue <double> big_queue;
       std::priority_queue <double, std::vector<double>, std::greater<double>> small_queue;
};
int main() {
       MedinFinder M;
       int test[] = { 6,10,1,7,99,4,33 };
       for (int i = 0; i < 7; i++) {
              M.addNum(test[i]);
              printf("%lf\n", M.findMedian());
       }
       return 0;
}

转载于:https://www.cnblogs.com/lihello/p/11520849.html

diaoxiu9083
关注
Rails
linyq@BambooFan ~
02-18 641
FJNU.1221DescriptionThere is a famous railway station in PopPush City. Country there is incredibly hilly. The station was built in last century. Unfortunately, funds were extremely limited that time
(stack)Rails(P1363)
jiangjiashi的博客
05-17 797
#include #include #include using namespace std; int go[1000000]; int main() { int i,j,k; int n; while (cin>>n,n) { while (true) { cin>>go[0]; if (go[0]==0) break; for (i=1;i<n
poj 1363
冰上游鱼
12-27 2527
终于考试完了，又可以学习啦！ poj1363，这道题是数据结构与算法中的经典问题，给定一组进栈顺序，问栈有多少种出去的顺序，而这个题是选择题中常考“下列出栈顺序中不合法的是？”。 拿到之后最直接的思路就是模拟进出栈，代码AC了，但是时间为94ms。感觉不应该啊，这么简单的题，必定有更高效的算法。 可是怎么更高效呢？ /* * ===========================
OpenJudg / Poj 1363 Rails
西门求雪的专栏
12-04 378
1.链接： http://poj.org/problem?id=1363 http://bailian.openjudge.cn/practice/1363 2.题目： Rails Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 24612   Accepted: 9644
堆栈练习1：POJ1363
isaacfeng的博客
04-28 319
火车进站出站问题。五年前的一个不会写的作业。 使用了STL，实际上并不必要，但是为了试一下。 开始的时候对于停止条件想的不是很清楚，后来发现放进去之前先试着查一下top，并且要保证栈非空的情况下。 后来交题的时候遇到了很玄学的问题，对于memset(B,0,sizeof(B));真的不理解。 sizeof(int)就WA了，不加这句话也会WA，但是我觉得这句话并没有什么意义啊。这是个问题，
leetcode答案-One-Day-One-LeetCode:记录每次练习LeetCode的答案
06-30
在LeetCode上，用户通常会遇到各种类型的编程问题，涵盖了数据结构（如数组、链表、栈、队列、树等）和算法（如排序、搜索、动态规划、回溯等）。这些问题有助于提升对计算机科学基础的理解，特别是对于那些寻求软件...
java-leetcode面试题解Stack之第225题用队列实现栈-题解.zip
最新发布
05-05
这道题目是LeetCode中的第225题，名为"用队列实现栈"（Implement Stack using Queues）。在这个问题中，我们需要使用两个队列来模拟栈的数据结构和操作，主要包含`push`、`pop`和`top`等基本功能。 栈是一种后进先...
leetcode卡-30-Day-LeetCoding-Challenge:一个存储我的LeetCode提交的挑战（Python）
07-06
leetcode卡30 天 LeetCoding 挑战 完全的！ 我为这个挑战提交的 LeetCode 代码库 (Python) 挑战链接： 注意：我还是 Python 新手，所以不要把这个 repo 作为学习 Python 的参考。 我的代码可能不够高效，也不够 ...
leetcode卡-Leetcode-May-30-day-Challenge:Leetcode-May-30-day-Challenge
07-06
leetcode卡力码 30 天 该存储库作为点对点通信渠道创建和维护，以便 CP 世界的新来者可以讨论他们对 Leetcode ...向“manthanchauhan/Leetcode-May-30-day-Challenge/master”提交 PR。 资源 教程：
leetcode伪代码-Queue-Stack:队列&栈的经典题目
06-30
本部分记录了leetcode队列和栈的一些经典题目，说到队列和栈我们就少不了说深度搜索（DFS）和广度搜索（BFS）当你完成这些题目之后，我相信你一定会对队列和栈以及DFS和BFS有重新的认识，我觉得这些题目才是正真的...
POJ 1363-Rails 简单栈
weimou66
01-30 365
Description There is a famous railway station in PopPush City. Country there is incredibly hilly. The station was built in last century. Unfortunately, funds were extremely limited that time. It ...
POJ1363 Rails(数据结构栈)
SeasonJoe的博客
01-27 486
题意： 一列火车从A站进入，B站开出，中间有一个站台，可以改变车厢顺序，原本是1~n，看输入的序列能否达到 要点： 就是模拟栈的压入弹出，如果栈顶元素对应的编号与输入的顺序一致就弹出，如果不一致就继续压入。最后如果栈是空的就说明顺序是合法的，否则不合法 15114206 Seasonal 1363 Accepted 164K 63MS C++ 646B 20
POJ 1363 Rails 判断出栈序列是否合法
weixin_30666753的博客
11-17 94
题目链接：http://poj.org/problem?id=1363　　（lrj白书习题） 题目大意：判断一个出栈序列能不能从1，2，3，……，n 经过栈处理后生成。 思路： Ⅰ：定理：出栈序列不合法 <=> 存在k,满足i<j<k,使得S[k]<S[i]<S[j]。(i,j,k是入站顺序，s[i],s[j],s[k]是出栈顺序)。 如果用这个定...
POJ 1363 Rails
long-long-ago
08-13 386
POJ 1363 RailsDescription There is a famous railway station in PopPush City. Country there is incredibly hilly. The station was built in last century. Unfortunately, funds were extremely limited that
POJ-----1363栈的模拟
blue_hpu的博客
07-26 276
Rails Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 31397   Accepted: 12199 Description There is a famous railway station in PopPush City. Country there is
【POJ】The Bottom of a Graph 强连通
poursoul
07-07 844
The Bottom of a Graph Time Limit: 3000MS Memory Limit: 65536K Total Submissions: 8636 Accepted: 3582 Description We will use the following (standard)
POJ1363 Rails（数据结构小实验）
pluto_cb的博客
10-11 233
题目四：Rails（***） [Description] ···There is a famous railway station in PopPush City. Country there is incredibly hilly. The station was built in last century. Unfortunately, funds were extremely limited...
微软数据结构与算法面试题41-60答案解析
例如，栈和队列常用于处理顺序操作，树结构则广泛应用于文件系统、数据库索引等领域，而哈希表则在快速查找和数据关联中发挥关键作用。 算法是解决问题的具体步骤，可以分为排序算法（如冒泡排序、选择排序、插入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值