本篇开始说明栈和队列的题目
232. Implement Queue using Stacks
//功能:使用栈结构执行队列结构的操作
//注意:只能使用栈结构的标准操作:即push、pop、peek、size、empty。
class Queue {
public:
stack<int> in,out;
// Push element x to the back of queue.
void push(int x) {
in.push(x);
}
// Removes the element from in front of queue.
void pop(void) {
peek();
out.pop();
}
// Get the front element.
int peek(void) {
if(out.empty())
{
while(in.size())
{
out.push(in.top());
in.pop();
}
}
return out.top();
}
// Return whether the queue is empty.
bool empty(void) {
return out.empty()&& in.empty();
}
};
总结:这也是一个老题目,怎样用栈的结构实现队列的功能。这里常见的方法就是构建两个stack,假设为in和out。两个栈的用处是不同的,in专门用来进行入队列操作,out专门用来出队列操作,不过需要进行的一个操作是,当out栈为空时,需要将in中的元素逐一pop出来,然后push到out中去。这样一倒,就实现了先进先出的队列的功能。
225. Implement Stack using Queues
//功能:使用队列执行栈结构的操作
//注意:只能使用队列结构的标准操作:即push、pop、front、size、empty.
class Stack {
public:
// Push element x onto stack.
queue<int> q1,q2;
void push(int x) {
if(q1.empty() && !q2.empty())
{
q1.push(x);
while(q2.size())
{
int x = q2.front();
q1.push(x);
q2.pop();
}
}
else if(q2.empty() && !q1.empty())
{
q2.push(x);
while(q1.size())
{
int x = q1.front();
q2.push(x);
q1.pop();
}
}
else if(q1.empty() && q2.empty())
q1.push(x);
}
// Removes the element on top of the stack.
void pop() {
if(!q1.empty())
q1.pop();
else if(!q2.empty())
q2.pop();
else
return;
}
// Get the top element.
int top() {
if(!q1.empty())
return q1.front();
else if(!q2.empty())
return q2.front();
else
return -1;
}
// Return whether the stack is empty.
bool empty() {
return q1.empty() && q2.empty();
}
};
//others code
class Stack {
public:
queue<int> que;
// Push element x onto stack.
void push(int x) {
que.push(x);
for(int i=0;i<que.size()-1;++i){
que.push(que.front());
que.pop();
}
}
// Removes the element on top of the stack.
void pop() {
que.pop();
}
// Get the top element.
int top() {
return que.front();
}
// Return whether the stack is empty.
bool empty() {
return que.empty();
}
};
总结:和上一道题刚刚相反,这道题是用队列表示栈。这道题有两种算法思路:
第一种思路:构建两个队列,始终保持一个队列为空,当push元素时,先将这个元素push到空的队列中,然后将另外一个非空的队列中的元素逐一pop出来,并push到前面那个只有一个元素的队列中去,这样后一个队列即为空了。前一个队列里元素的排列顺序即按照后进先出的栈顺序来排的。
第二种思路:这里只用构建一个队列就可以完成,当push元素时,push到队列的队尾,这是假设队列前面有n个元素,那么就执行一个n次的循环,循环每次从队列的头部pop出一个元素,然后将钙元素push到队尾,直到开始push进队尾的元素到对头,由于每次push都会执行循环,因此循环后的队列里元素的顺序也是按照先进后出的栈顺序排列的。
从以上两种方法可以看出,由于每次push进一个元素,队列里的其他元素都需要自行位置转换操作,因此用队列来模拟栈其效率其实是不高的。
//功能:构建一个最小栈的数据结构,使其不止能满足栈的特点,而且还能返回栈中最小元素的值
class MinStack {
public:
stack<int> data;
stack<int> mindata;
/** initialize your data structure here. */
MinStack() {
}
void push(int x) {
if(mindata.empty())
{
data.push(x);
mindata.push(x);
}
else
{
data.push(x);
if(x <= mindata.top())
mindata.push(x);
}
}
void pop() {
if(data.top() == mindata.top())
{
data.pop();
mindata.pop();
}
else
data.pop();
}
int top() {
return data.top();
}
int getMin() {
return mindata.top();
}
};
//others code
class MinStack {
public:
/** initialize your data structure here. */
MinStack() {
;
}
void push(int x) {
data.push(x);
if(minData.empty())
minData.push(x);
else
minData.push(min(x,minData.top()));
}
void pop() {
if(!data.empty())
{
data.pop();
minData.pop();
}
else
cerr<<"empty"<<endl;
}
int top() {
if(data.empty())
cerr<<"empty"<<endl;
return data.top();
}
int getMin() {
if(minData.empty())
cerr<<"empty"<<endl;
return minData.top();
}
private:
stack<int> data;
stack<int> minData;
};
总结:这道题是让构建一个栈,使其支持push, pop, top, 和返回栈中最小的元素值getMin的操作,前面的三个自然不同操心,普通栈就可以实现,关键是怎么让一个栈记住其最小值元素呢,这里的思路是:构建另外一个栈,假设为minstack,让其专门维护我们的主栈,记录主栈的最小元素。当需要push一个元素的时候,先push该元素到主栈,在判断维护栈minstack的情况,若为空,则好说,push元素到维护栈,若不为空,判断维护栈栈顶元素top和该元素的大小,若该元素小于等于栈顶元素(注意等于的情况不可少,否则栈中出现相同元素时会出错),则将该元素push进minstack,如大于,则不同操作。当需要pop元素的时候,我们比较主栈栈顶元素与维护栈栈顶元素的大小,若主栈元素小于等于维护栈栈顶,则不但要pop主栈元素,还要pop维护栈元素。就这样,实现了维护栈可动态记录主栈最小元素的功能。
还有一种稍微有点区别的方式上面第二段代码,该段代码中主栈和维护栈元素自始至终是一样多的,而且一同push,一同pop,唯一不同的是,当push进主栈的元素非维护栈中的最小元素时,push进维护栈的是维护栈的最小元素,而不是push进主栈的元素x,这样写的好处就是在pop时直接pop就好了,不用再判断。
20. Valid Parentheses
<span style="font-size:18px;">//My code
//功能:给定一个字符串只包含'(',')','{','}','[',']'这六种字符,请判断我们输入的这六种字符是否是合法的。
合法的标准是三种括号应该正确的闭合,<span style="box-sizing: border-box; padding: 2px 4px; border-radius: 4px;"></span><code style="box-sizing: border-box; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; font-size: 12.6px; padding: 2px 4px; color: rgb(199, 37, 78); border-radius: 4px; line-height: 30px; background-color: rgb(249, 242, 244);">"()"</code><span style="color: rgb(51, 51, 51); font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; font-size: 14px; line-height: 30px;"> 和 </span><code style="box-sizing: border-box; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; font-size: 12.6px; padding: 2px 4px; color: rgb(199, 37, 78); border-radius: 4px; line-height: 30px; background-color: rgb(249, 242, 244);">"()[]{}"</code><span style="color: rgb(51, 51, 51); font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; font-size: 14px; line-height: 30px;">都是合法的 但是 </span><code style="box-sizing: border-box; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; font-size: 12.6px; padding: 2px 4px; color: rgb(199, 37, 78); border-radius: 4px; line-height: 30px; background-color: rgb(249, 242, 244);">"(]"</code><span style="color: rgb(51, 51, 51); font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; font-size: 14px; line-height: 30px;"> 和</span><code style="box-sizing: border-box; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; font-size: 12.6px; padding: 2px 4px; color: rgb(199, 37, 78); border-radius: 4px; line-height: 30px; background-color: rgb(249, 242, 244);">"([)]"</code><span style="color: rgb(51, 51, 51); font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; font-size: 14px; line-height: 30px;">就不是。</span>
class Solution {
public:
stack<char> str;
bool isValid(string s) {
int len = s.length();
for(int i = 0; i < len; i++)
{
if(s[i] == '(' || s[i] == '{' || s[i] == '[')
{
str.push(s[i]);
}
else
{
if(str.empty())
return false;
if(s[i] == ')')
{
if('(' == str.top())
{
str.pop();
}
else
{
return false;
}
}
else if(s[i] == '}')
{
if('{' == str.top())
{
str.pop();
}
else
{
return false;
}
}
else if(s[i] == ']')
{
if('[' == str.top())
{
str.pop();
}
else
{
return false;
}
}
}
}
if(!str.empty())
return false;
return true;
}
};</span>
//others code
class Solution {
public:
bool isValid(string s) {
stack<char> paren;
for (char& c : s) {
switch (c) {
case '(':
case '{':
case '[': paren.push(c); break;
case ')': if (paren.empty() || paren.top()!='(') return false; else paren.pop(); break;
case '}': if (paren.empty() || paren.top()!='{') return false; else paren.pop(); break;
case ']': if (paren.empty() || paren.top()!='[') return false; else paren.pop(); break;
default: ; // pass
}
}
return paren.empty() ;
}
};
<pre name="code" class="cpp">//others code
bool isValid(string s) { stack<char> st; for (int i = 0;i < s.size();++i) { if (!st.empty()&&(s[i]==')'&&st.top()=='('||s[i]==']'&&st.top()=='['||s[i]=='}'&&st.top()=='{')) st.pop(); else st.push(s[i]); } return st.empty()?true:false;}
//others code
class Solution {
public:
bool isValid (string s) {
std::stack<char> cache;
std::map<char,char> symbolPairs = {{')','('},{']','['},{'}','{'}};
for (std::string::iterator iter = s.begin(); iter<s.end(); iter++)
{
char letter = *iter;
if (letter == '(' || letter == '[' || letter == '{') //first half
cache.push (letter);
else if (letter == ')' || letter == ']' || letter == '}')
{
if (cache.size()==0)
return false;
char potentialMatch = cache.top();
cache.pop();
if (potentialMatch != symbolPairs.at(letter))
return false;
}
}
if (cache.size() > 0)
return false;
else
return true;
}
};
总结:这一题是典型的使用压栈的方式解决的问题,题目中还有一种valid情况没有说明,需要我们自己考虑的,就是"({[]})"这种层层嵌套但
可以完全匹配的,也是valid的一种。解题思路是这样的:
我们对字符串S中的每一个字符C,如果C不是右括号,就压入栈stack中。如果C是右括号,判断stack是不是空的,空则说明没有左括号,直接返回not valid,非空就取出栈顶的字符pre来对比,如果是匹配的,就弹出栈顶的字符,继续取S中的下一个字符;如果不匹配,说明不是valid的,直接返回。当我们遍历了一次字符串S后,注意这里还有一种情况,就是stack中还有残留的字符没有得到匹配,即此时stack不是空的,这时说明S不是valid的,因为只要valid,一定全都可以得到匹配使左括号弹出。
上面的题目中给出了多种答案,思路都是相似的,但是代码的简介程度就有很明显的差别了,我自己写的完全是为了通过答案,代码显的很冗余,别人写的第一种就显得很简单,用到了范围for和switch语句。最后一种答案用到了map容器,虽然觉得没大比要,但是代码写的还是值得学习的。