C++练习11：栈和队列

介绍

栈(stack) : 具有先进后出，后进先出的特点。

C++ Stack（堆栈） 是一个容器类的改编，为程序员提供了堆栈的全部功能，——也就是说实现了一个先进后出（FILO）的数据结构。

empty()   堆栈为空则返回真
pop()     移除栈顶元素
push()    在栈顶增加元素
size()    返回栈中元素数目
top()     返回栈顶元素

C++ stack 的栈是不能遍历的

队列(Queue) : 具有先进先出的特点。

q.empty()               如果队列为空返回true，否则返回false
q.size()                返回队列中元素的个数
q.pop()                 删除队列首元素但不返回其值
q.front()               返回队首元素的值，但不删除该元素
q.push()                在队尾压入新元素
q.back()                返回队列尾元素的值，但不删除该元素

stack

题目1:获取stack中最大的元素

解题思路：使用2个stack,一个是常规的stack,另一个stack 存储在比较过程中大的元素。

class stackWithMax
{private:stack<int> valueStack;stack<int> maxStack;public:void push(int);int pop();int max();
};void stackWithMax::push(int value)
{if(maxStack.empty() || maxStack.top() <=value){maxStack.push(value);}valueStack.push(value);
}int stackWithMax::pop()
{int value=valueStack.top();valueStack.pop();if(value == maxStack.top()){maxStack.pop()}return value;
}int stackWithMax::max()
{return maxStack.pop();
}

题目2:通过stack 实现队列Queue

我们知道stack输出顺序和queue的顺序是相反的
解题思路: 通过两个栈，互相倾倒的方式，当一个栈的元素，倾倒另一个栈上，从而使得原来栈中最后出栈的元素最先出栈，从而颠倒了出栈的顺序。

class Queue
{private:
stack<int> inputStack;
stack<int> outputStack;
public:
void enqueue(int);
int dequeue();
];void Queue::enqueue(int value)
{inputStack.push(value);
}int Queue::dequeue()
{int value;if(!outputStack.empty()){value=outputStak.top();outputStack.pop();return value;}while(!inputStack.empty()){.outputStack.push(inputStack.top())inputStack.pop();}value=outputStack.top();outputStack.pop();return value;
}

题目3: 如何对Stack进行升序排列

解题思路:假设使用两个Stack A 和 B ,队列A中元素是没有顺序的，将队列A中的元素有序的加入队列B中，从队列A中取一个元素，假设该元素不符合队列B当前的排列顺序，我们就取stackB上的元素，直到元素可以按顺序入栈。

stack<int> sort(stack<int> &input)
{stack<int> output;while(!input.empty()){int value=input.top();input.pop();while(!output.empty() && output.top <value){input.push(output.top())output.pop();}output.push(value);}return output;
}

“save or latter” 问题

有一类问题有这样的特性：当前节点的解依赖后驱节点。
对于某一类当前节点，如果不能获知后驱节点，就无法得到有意义的解。这类问题可以通过stack（或等同于stack的若干个临时变量）

解决：先将当前节点入栈，然后看其后续节点的值，直到其依赖的所有节点都完备时，再从栈中弹出该节点求解。某些时候，甚至需要反复这个过程：将当前节点的计算结果再次入栈，直到其依赖的后续节点完备。

题目1：验证括号的有效性

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

注意：空字符串可被认为是有效字符串

思路

由于要对照字符串对称位置上的括号是否对应，决定采用栈来解决这一问题，若字符串长度不为偶数则直接返回false，遍历字符串，读到前括号时入栈，读到后括号时若栈空则返回false,若栈不空则用栈顶元素与其比较，能对应则出栈，不能则返回false。最后检查栈空，若空则返回true

代码实现:

bool isLeftParentheses(char left,char right)
{return input == '(' || input == '['  || input == '{';
}bool isMatchParentheses(char left,char right)
{swithc(left){case '(':return right == ')';case '[':return right == ']';case '{':return right == '}';}return false;
}bool isValidParentheses(string input)
{stack<char> parenthesesStack;for(int i=0;i<input.length;i++){if(isLeftParentheses(input[i]))parenthesesStack.push(input[i]);else:{if (parenthesesStack.empty() || !isMatchParentheses(parenthesesStack.top(),inut[i])){return false;}else if(!parenthesesStack.empty() && isMatchParentheses(parenthesesStack.top(),inut[i]) ){parenthesesStack.pop();}else{return false;}}}return parenthesesStack.empty();
}

代码2

{class Solution {public:bool isValid(string s) {if(s.size()%2!=0){return false;}stack <char>stk;for(int i=0;i<s.size();i++){if(s[i]=='('||s[i]=='{'||s[i]=='['){stk.push(s[i]);}else{if(stk.empty()){return false;}else{if(s[i]==')'&&stk.top()=='('){stk.pop();}else if(s[i]=='}'&&stk.top()=='{'){stk.pop();}else if(s[i]==']'&&stk.top()=='['){stk.pop();}else{return false;}}}}return stk.empty();}
};}

参考博客：C++有效的括号

用stack解决`Top-Down`结构的问题

所谓的Top-Down结构，从逻辑理解角度来看，实际上就是一种树形结构，从顶层出发，逐渐向下扩散，例如二叉树的周游问题。在实际运算的时候，我们先解决子问题，再利用子问题的结构解决当前问题。

由于Stack的LIFO特征，可以利用Stack数据结构消除递归。Recursion通常用函数调用自身实现，在系统调用的时候系统会分配额外的空间，并且需要用指针记录返回的位置，故overhead比较大

题目1：二叉树的中序遍历

中序遍历：首先遍历根结点的左子树，然后访问根结点，最后中序遍历其右子树。

未完待续。。。