首页 > 代码库 > 算法总结
算法总结
一 基础知识
1.
均为线性表，可以由数组或链表实现
栈：先进后出，操作均在栈顶进行
队列：先进先出，队尾进，队首出
2. STL stack & queue
stack 常见操作：
s.push(x)：入栈 （void类型）
s.pop()： 出栈 （void类型，只删除，不返回元素）
s.top()： 返回栈顶元素
s.size()：返回栈元素个数
s.empty() ：判断栈是否为空
queue 常见操作：
q.push(x): 入队
q.pop(): 出队 （void类型，只删除，不返回队首元素）
q.front(): 访问返回对首元素
q.back(): 访问返回队尾元素
q.size():返回队列元素个数
q.empty(): 判断队列是否为空
3.概念理解相关题型
3.1 Implement Stack using Queues （leetcode 225 https://leetcode.com/problems/implement-stack-using-queues/）
思路：使用两个队列实现，其中一个队列为空，用来进行颠倒顺序和输出队尾元素。
入栈操作： 向非空队列内入队即可
出栈操作：将非空队列除队尾元素外的所有元素导入另一个空队列，剩余队尾元素即为待应该待出栈元素
top()操作： 同出栈，注意只需访问返回，不需要让其出队，即仍需将其导入另一队列
注意：两队列地位平等，均可能用作储存和转移工作
class Stack {
private:
queue<int> q1,q2;
public:
// Push element x onto stack.
void push(int x) {
if(!q1.empty()){
q1.push(x);
}
else{
q2.push(x);
}
}
// Removes the element on top of the stack.
void pop() {
if(!q1.empty()){
while(q1.size() > 1){
q2.push(q1.front());
q1.pop();
}
q1.pop();
}else{
while(q2.size() > 1){
q1.push(q2.front());
q2.pop();
}
q2.pop();
}
}
// Get the top element.
int top() {
if(!q1.empty()){
while(q1.size() > 1){
q2.push(q1.front());
q1.pop();
}
int ans = q1.front();
q2.push(q1.front());
q1.pop();
return ans;
}else{
while(q2.size() > 1){
q1.push(q2.front());
q2.pop();
}
int ans = q2.front();
q1.push(q2.front());
q2.pop();
return ans;
}
}
// Return whether the stack is empty.
bool empty() {
if(q1.empty() && q2.empty()){
return true;
}
return false;
}
};
3.2 Implement Queue using Stacks （leetcode 232 https://leetcode.com/problems/implement-queue-using-stacks/）
思路：
两个堆栈，s1负责入队，s2负责反向并出队
每次入队直接进入s1，出队操作先将s1所有元素压入s2，则栈顶元素即为待出队元素，出队后压回s1，恢复原状。
class Queue {
private:
stack<int> s1,s2;
public:
// Push element x to the back of queue.
void push(int x) {
s1.push(x);
}
// Removes the element from in front of queue.
void pop(void) {
while(!s1.empty()){
s2.push(s1.top()); // 注意STL栈中，top只返回不出栈，pop只出栈不返回
s1.pop();
}
s2.pop();
while(!s2.empty()){
s1.push(s2.top());
s2.pop();
}
}
// Get the front element.
int peek(void) {
while(!s1.empty()){
s2.push(s1.top());
s1.pop();
}
int ans = s2.top();
while(!s2.empty()){
s1.push(s2.top());
s2.pop();
}
return ans;
}
// Return whether the queue is empty.
bool empty(void) {
if(s1.empty() && s2.empty()){
return true;
}
return false;
}
};
3.3 Min Stack (leetcode 155 https://leetcode.com/problems/min-stack/)
要求：实现可以返回最小元素的栈
思路：使用两个栈，一个栈s1正常出入，另一个储s2存最小值信息，当当前元素比s2栈顶元素小，入当前元素，否则再入一份栈顶元素
注意：由于s1,s2元素一样多，出栈时也应一起出栈。
class MinStack {
private:
stack<int> s1,s2;
public:
void push(int x) {
s1.push(x);
if(!s2.empty() && x > s2.top()){
s2.push(s2.top());
}else{
s2.push(x);
}
}
void pop() {
s1.pop();
s2.pop();
}
int top() {
return s1.top();
}
int getMin() {
return s2.top();
}
};
二. 栈与队列应用 （结合数据结构教材中的应用）
1. 典型应用场合
典型应用栈的场合有： 逆序输出 （进制转换），递归嵌套（栈混洗，括号匹配），延迟缓冲（表达式计算），栈式计算（逆波兰表达式）
举例如下：
1.1 十进制数向n进制转换的栈实现
思路：除以n取余数，以此存放在栈中，输出时由栈的特点反向输出得解
void convert(stack <char>& S, int n,int base) {
static char digit[] =
{‘0‘,‘1‘,‘2‘,‘3‘,‘4‘,‘5‘,‘6‘,‘7‘,‘8‘,‘9‘,‘A‘,‘B‘,‘C‘,‘D‘,‘E‘,‘F‘};
while(n > 0){
int remainder = (int)(n % base);
S.push(digit[remainder]);
n /= base;
}
}
1.2 栈混洗（元素出入栈合法顺序判断）
思路：使用栈模拟，对于s，如果当前要出栈元素正好在栈顶，则必须出栈;否则入栈，出现矛盾则说明不合法
bool isPossible(vector<int>& in, vector<int>& out){
stack<int> s;
for(int i = 0,j = 0;j<out.size();j++){
while(s.empty() || s.top!= out[j]){
if(i > in.size()){
return false;
}
s.push(in[++]);
}
s.pop();
}
return true;
}
补充： n个元素的合法出入栈个数为卡特兰数 （2n!）/ n! /(n+1)!
1.3 括号匹配 （leetcode 20 https://leetcode.com/problems/valid-parentheses/）
思路：遍历序列，遇到所有类型左括号，入栈；遇到右括号，判定栈顶元素与之是否匹配，匹配则出栈，不匹配则说明整体不匹配
class Solution {
public:
bool isValid(string s) {
stack<char> S;
for(int i = 0; i < s.length(); i++){
if(s[i] == ‘(‘ || s[i] == ‘[‘ || s[i] == ‘{‘){
S.push(s[i]);
continue;
}
if(s[i] == ‘)‘){
if(S.empty() || S.top() != ‘(‘){
return false;
}
S.pop();
continue;
}
if(s[i] == ‘]‘){
if(S.empty() || S.top() != ‘[‘){
return false;
}
S.pop();
continue;
}
if(s[i] == ‘}‘){
if(S.empty() || S.top() != ‘{‘){
return false;
}
S.pop();
continue;
}
}
return S.empty();
}
};
1.4 逆波兰表达式求解 （leetcode 150 https://leetcode.com/problems/evaluate-reverse-polish-notation/）
思路：根据逆波兰表达式定义，建立栈
遍历字符串，遇到数字，入栈，遇到运算符，取出栈顶两元素执行相应计算后将结果入栈
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> s;
for(int i = 0;i < tokens.size();i++){
if(tokens[i] == "+" || tokens[i] == "-" || tokens[i]== "*" || tokens[i] == "/"){
int num1 = s.top();
s.pop();
int num2 = s.top();
s.pop();
if(tokens[i] == "+"){
int num = num1 + num2;
s.push(num);
}
if(tokens[i] == "-"){
int num = num2 - num1;
s.push(num);
}
if(tokens[i] == "*"){
int num = num2 * num1;
s.push(num);
}
if(tokens[i] == "/"){
int num = num2 / num1;
s.push(num);
}
}
else{
s.push(atoi(tokens[i].c_str()));
}
}
int ans = s.top();
return ans;
}
};
算法总结