栈
- 一个 后进先出 的数据结构
- JavaScript中没有栈，但可以用 Array 实现栈的所有功能
- 栈的常用操作：
push,pop,stack[stack.length - 1]- 栈顶元素
栈的应用场景
- 需要 后进先出 的场景
- 比如：十进制转二进制、判断字符串的括号是否有效、函数调用堆栈······
场景一：十进制转二进制
- 后出来的余数反而要排到前面
- 把余数依次入栈，然后再出栈，就可以实现余数倒序输出
场景二：有效的括号
- 越靠后的左括号，对应的右括号越靠前
- 左括号入栈，右括号出栈，最后栈空即合法
LeetCode：20. 有效的括号
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
- 左括号必须用相同类型的右括号闭合。
- 左括号必须以正确的顺序闭合。
- 每个右括号都有一个对应的相同类型的左括号。
示例 1：
输入：s = "()"
输出：true
示例 2：
输入：s = "()[]{}"
输出：true
示例 3：
输入：s = "(]"
输出：false
思路：
- 对于没有闭合的左括号而言，越靠后的左括号，对应的右括号越靠前
- 满足后进先出，考虑用栈
解题步骤：
- 新建一个栈
- 扫描字符串，遇左括号入栈，遇到和 栈顶 括号类型匹配的右括号就出栈，类型不匹配直接判定为不合法
- 最后栈空了就合法，否则不合法
/**
* @param {string} s
* @return {boolean}
*/
var isValid = function(s) {
let stack = []
for(let i of s) {
if(i == '[' || i == '{' || i == '(') {
stack.push(i)
}else {
let top = stack[stack.length - 1];
if((i == ']' && top == '[') || (i == '}' && top == '{') || (i == ')' && top == '(')) {
stack.pop()
}else {
return false
}
}
}
return stack.length === 0;
};
时间复杂度：O(n)
空间复杂度：O(n)
场景三：函数调用堆栈
- 最后调用的函数，最先执行完
- JS 解释器使用栈来控制函数的调用顺序
前端与栈：JS 中的和函数调用堆栈
const func1 = () => {
func2()
};
const func2 = () => {
func3()
};
const func3 = () => {};
func1();
LeetCode：71. 简化路径
给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格 绝对路径 （以 '/' 开头），请你将其转化为更加简洁的规范路径。
在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （..） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。任意多个连续的斜杠（即，'//'）都被视为单个斜杠 '/' 。 对于此问题，任何其他格式的点（例如，'...'）均被视为文件/目录名称。
请注意，返回的 规范路径 必须遵循下述格式：
- 始终以斜杠
'/'开头。 - 两个目录名之间必须只有一个斜杠
'/'。 - 最后一个目录名（如果存在）不能 以
'/'结尾。 - 此外，路径仅包含从根目录到目标文件或目录的路径上的目录（即，不含
'.'或'..'）。
返回简化后得到的 规范路径 。
示例 1：
输入：path = "/home/"
输出："/home"
解释：注意，最后一个目录名后面没有斜杠。
示例 2：
输入：path = "/../"
输出："/"
解释：从根目录向上一级是不可行的，因为根目录是你可以到达的最高级。
示例 3：
输入：path = "/home//foo/"
输出："/home/foo"
解释：在规范路径中，多个连续斜杠需要用一个斜杠替换。
示例 4：
输入：path = "/a/./b/../../c/"
输出："/c"
思路：
- 碰见
'..'即为上一路径，需将最后一个元素弹出 - 满足后进先出
解题步骤：
- 利用
'/'将路径分隔开，不为''即为路径，加入栈； - 碰见
'//'或者.都是当前路径，无需加入； - 碰见
'..'即为上一路径，将栈顶元素弹出； - 返回栈拼接的字符串
/**
* @param {string} path
* @return {string}
*/
var simplifyPath = function(path) {
const names = path.split('/');
const stack = [];
for(let name of names) {
if (name === '..') {
if(stack.length) {
stack.pop();
}
}else if(name.length && name !== '.') {
stack.push(name)
}
}
return '/' + stack.join('/')
};
LeetCode：150. 逆波兰表达式求值
给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。
请你计算该表达式。返回一个表示表达式值的整数。
注意：
- 有效的算符为
'+'、'-'、'*'和'/'。 - 每个操作数（运算对象）都可以是一个整数或者另一个表达式。
- 两个整数之间的除法总是 向零截断 。
- 表达式中不含除零运算。
- 输入是一个根据逆波兰表示法表示的算术表达式。
- 答案及所有中间计算结果可以用 32 位 整数表示。
示例 1：
输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
示例 2：
输入：tokens = ["4","13","5","/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6
示例 3：
输入：tokens = ["10","6","9","3","+","-11"," ","/"," ","17","+","5","+"]
输出：22
解释：该算式转化为常见的中缀算术表达式为：
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22
思路：
- 碰见
'+'、'-'、'*'和'/'就取前面邻近的两个值做运算 - 满足后进先出
解题步骤：
- 将
tokens的值依次入栈 - 碰见
'+'、'-'、'*'和'/'就取前面邻近的两个值做运算并放入栈中 - 继续上一步操作
/**
* @param {string[]} tokens
* @return {number}
*/
var evalRPN = function(tokens) {
let stack = [];
for(let token of tokens) {
if(token !== "+" && token !== "-" && token !== "*" && token !== "/") {
stack.push(token)
}else {
let num1 = Number(stack.pop());
let num2 = Number(stack.pop());
if(token === '+') {
stack.push(parseInt(num1 + num2))
}else if(token === '-') {
stack.push(parseInt(num2 - num1))
}else if(token === '*') {
stack.push(parseInt(num1 * num2))
}else if(token === '/') {
stack.push(parseInt(num2 / num1))
}
}
}
return stack[0]
};
