JZ9 用两个栈实现队列
简单 通过率：41.16% 时间限制：1秒 空间限制：64M
知识点栈
描述
用两个栈来实现一个队列，使用n个元素来完成 n 次在队列尾部插入整数(push)和n次在队列头部删除整数(pop)的功能。
队列中的元素为int类型。保证操作合法，即保证pop操作时队列内已有元素。
数据范围： n≤1000
要求：存储n个元素的空间复杂度为 O(n) ，插入与删除的时间复杂度都是 O(1)
示例1
输入：
[“PSH1”,“PSH2”,“POP”,“POP”]
返回值：
1,2
说明：
“PSH1”:代表将1插入队列尾部
“PSH2”:代表将2插入队列尾部
"POP“:代表删除一个元素，先进先出=>返回1
"POP“:代表删除一个元素，先进先出=>返回2
示例2
输入：
[“PSH2”,“POP”,“PSH1”,“POP”]
返回值：
2,1
class Solution
{
public:
void push(int node) {
stack_in.push(node);
}
int pop() {
if (stack_out.empty()){
while (!stack_in.empty()){
stack_out.push(stack_in.top());
stack_in.pop();
}
}
int res = stack_out.top();
stack_out.pop();
return res;
}
private:
stack<int> stack_in;
stack<int> stack_out;
};
JZ30 包含min函数的栈
简单 通过率：34.99% 时间限制：1秒 空间限制：64M
知识点栈
描述
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的 min 函数，输入操作时保证 pop、top 和 min 函数操作时，栈中一定有元素。
此栈包含的方法有：
push(value):将value压入栈中
pop():弹出栈顶元素
top():获取栈顶元素
min():获取栈中最小元素
数据范围：操作数量满足 0≤n≤300 ，输入的元素满足 ∣val∣≤10000
进阶：栈的各个操作的时间复杂度是 O(1) ，空间复杂度是 O(n)
示例:
输入: [“PSH-1”,“PSH2”,“MIN”,“TOP”,“POP”,“PSH1”,“TOP”,“MIN”]
输出: -1,2,1,-1
解析:
"PSH-1"表示将-1压入栈中，栈中元素为-1
"PSH2"表示将2压入栈中，栈中元素为2，-1
“MIN”表示获取此时栈中最小元素==>返回-1
"TOP"表示获取栈顶元素==>返回2
"POP"表示弹出栈顶元素，弹出2，栈中元素为-1
"PSH1"表示将1压入栈中，栈中元素为1，-1
"TOP"表示获取栈顶元素==>返回1
“MIN”表示获取此时栈中最小元素==>返回-1
示例1
输入：
[“PSH-1”,“PSH2”,“MIN”,“TOP”,“POP”,“PSH1”,“TOP”,“MIN”]
返回值：
-1,2,1,-1
class Solution
{
public:
void push(int value) {
if (min_sta.empty() || value < min_sta.top()) {
min_sta.push(value);
} else {
min_sta.push(min_sta.top());
}
sta.push(value);
// sta:5 7 4 8 3 6 2 9 1
// min_sta:5 5 4 4 3 3 2 2 1
}
void pop(){
min_sta.pop();
sta.pop();
}
int top(){
return sta.top();
}
int min() {
return min_sta.top();
}
stack<int> sta;
stack<int> min_sta;
};
JZ31 栈的压入、弹出序列
中等 通过率：31.62% 时间限制：1秒 空间限制：64M
知识点栈
描述
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。
例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。
- 0<=pushV.length == popV.length <=1000
- -1000<=pushV[i]<=1000
- pushV 的所有数字均不相同
示例1
输入：
[1,2,3,4,5],[4,5,3,2,1]
返回值：
true
说明：
可以通过push(1)=>push(2)=>push(3)=>push(4)=>pop()=>push(5)=>pop()=>pop()=>pop()=>pop()
这样的顺序得到[4,5,3,2,1]这个序列，返回true
示例2
输入：
[1,2,3,4,5],[4,3,5,1,2]
返回值：
false
说明：
由于是[1,2,3,4,5]的压入顺序，[4,3,5,1,2]的弹出顺序，要求4，3，5必须在1，2前压入，且1，2不能弹出，但是这样压入的顺序，1又不能在2之前弹出，所以无法形成的，返回false
class Solution
{
public:
bool IsPopOrder(vector<int> pushV,vector<int> popV) {
if ( pushV.empty() ) {
return false;
}
stack<int> sta;
for (int i = 0, j = 0; i < pushV.size(); i++){
sta.push(pushV[i]);
while ( !sta.empty() && sta.top() == popV[j] ){
sta.pop();
j++;
}
}
return sta.empty();
}
};
JZ73 翻转单词序列
这道题目没有使用栈，而是使用两轮翻转。
简单 通过率：21.65% 时间限制：1秒 空间限制：64M
知识点字符串双指针
描述
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“nowcoder. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a nowcoder.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？
数据范围：1≤n≤100
进阶：空间复杂度 O(n) ，时间复杂度 O(n) ，保证没有只包含空格的字符串
示例1
输入：
“nowcoder. a am I”
返回值：
“I am a nowcoder.”
示例2
输入：
“”
返回值：
“”
C++ reverse函数的用法
reverse函数功能是逆序（或反转），多用于字符串、数组、容器。
头文件是#include
reverse函数用于反转在[first,last)范围内的顺序
包括first指向的元素，不包括last指向的元素，
reverse函数无返回值
string str=“hello world , hi”;
reverse(str.begin(),str.end());//str结果为 ih , dlrow olleh
vector v = {5,4,3,2,1};
reverse(v.begin(),v.end());//容器v的值变为1,2,3,4,5
class Solution
{
public:
string ReverseSentence(string str) {
//第一步：整体翻转
reverse(str.begin(), str.end());
// begin() begin()+1 begin()+2
// 0 1 2
//第二步：局部翻转
int offset = 0;
for (int i = 0; i < str.size(); i++) {
if (str[i] == ' ') {
reverse(str.begin() + offset, str.begin() + i);
// 下一个单词的迭代器：begin()+i+1
offset = i + 1;
} else if (i == str.size() - 1) {
//到达字符串末尾，最后一个单词使用end()
reverse(str.begin() + offset, str.end());
}
}
return str;
}
};
JZ59 滑动窗口的最大值
较难 通过率：27.60% 时间限制：1秒 空间限制：256M
知识点堆双指针队列
描述
给定一个长度为 n 的数组 nums 和滑动窗口的大小 size ，找出所有滑动窗口里数值的最大值。
例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。
数据范围： 1≤size≤n≤10000，数组中每个元素的值满足 ∣val∣≤10000
要求：空间复杂度 O(n)，时间复杂度 O(n)
示例1
输入：
[2,3,4,2,6,2,5,1],3
返回值：
[4,4,6,6,6,5]
示例2
输入：
[9,10,9,-7,-3,8,2,-6],5
返回值：
[10,10,9,8]
示例3
输入：
[1,2,3,4],3
返回值：
[3,4]
第一种方法：两层循环
class Solution {
public:
vector<int> maxInWindows(const vector<int>& num, int size) {
vector<int> res;
if (num.size() == 0 || num.size() < size || size < 1) {
return res;
}
for (int i = 0; i <= num.size() - size; i++) {
int max = 0;
for (int j = i; j <= i + size - 1; j++) {
if (max < num[j]) {
max = num[j];
}
}
res.push_back(max);
}
return res;
}
};
第二种方法：队列deque
class Solution {
public:
vector<int> maxInWindows(const vector<int>& num, int size) {
vector<int> ret;
if (num.size() == 0 || size < 1 || num.size() < size) {
return ret;
}
deque<int> deq;
for (int i = 0; i < num.size(); ++i) {
while (!deq.empty() && num[deq.back()] < num[i]) {
//后面的大数把前面的小数吃掉
deq.pop_back();
}
deq.push_back(i);
// 判断队列的头部的下标是否过期
// 窗口的起始下标 i - size + 1
// 窗口的结束下标 i
if (deq.front() < i - size + 1) {
deq.pop_front();
}
// 判断是否形成了窗口
// 第一个窗口的起始下标：0
// 第一个窗口的结束下标：size - 1
if (i >= size - 1) {
ret.push_back(num[deq.front()]);
}
}
return ret;
}
};
BM44 有效括号序列
题目
题解(283)
讨论(379)
排行
面经new
简单 通过率：33.39% 时间限制：1秒 空间限制：256M
知识点
栈
字符串
描述
给出一个仅包含字符’(‘,’)‘,’{‘,’}‘,’[‘和’]',的字符串，判断给出的字符串是否是合法的括号序列
括号必须以正确的顺序关闭，"()“和”()[]{}“都是合法的括号序列，但”(]“和”([)]"不合法。
数据范围：字符串长度 0\le n \le 100000≤n≤10000
要求：空间复杂度 O(n)O(n)，时间复杂度 O(n)O(n)
示例1
输入：
“[”
复制
返回值：
false
复制
示例2
输入：
“[]”
复制
返回值：
true
复制
class Solution {
public:
/**
*
* @param s string字符串
* @return bool布尔型
*/
bool isValid(string s) {
stack<char> sta;
for (int i = 0; i < s.length(); ++i) {
if (s[i] == '(') {
sta.push(')');
} else if (s[i] == '[') {
sta.push(']');
} else if (s[i] == '{') {
sta.push('}');
} else if (sta.empty()) {
return false;
} else if (s[i] == sta.top()) {
sta.pop();
}
}
return sta.empty();
}
};
2115
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
