本篇开始说明栈和队列的题目
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();
}
};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,唯一不同的是，当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//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;
}
};我们对字符串S中的每一个字符C，如果C不是右括号，就压入栈stack中。如果C是右括号，判断stack是不是空的，空则说明没有左括号，直接返回not valid，非空就取出栈顶的字符pre来对比，如果是匹配的，就弹出栈顶的字符，继续取S中的下一个字符；如果不匹配，说明不是valid的，直接返回。当我们遍历了一次字符串S后，注意这里还有一种情况，就是stack中还有残留的字符没有得到匹配，即此时stack不是空的，这时说明S不是valid的，因为只要valid，一定全都可以得到匹配使左括号弹出。
上面的题目中给出了多种答案，思路都是相似的，但是代码的简介程度就有很明显的差别了，我自己写的完全是为了通过答案，代码显的很冗余，别人写的第一种就显得很简单，用到了范围for和switch语句。最后一种答案用到了map容器，虽然觉得没大比要，但是代码写的还是值得学习的。
104
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
