sjsjs11的博客

我们可以发现，反转可以看作改变添加字符的方向，所以我们定义一个双端队列que和一个用来判断方向的k，一旦遇到i就令k取反，然后来判断要从前面加入元素还是后面加入元素，最后根据k的方向来从前往后或者从后往前来输出双端队列的字符，储存在res中。，其中 n 是字符串 s 的长度。，即为双端队列需要使用的空间。

从 [1, 2, 3, 4, 5, 6] 的中间位置弹出元素，返回 3 ，数组变为 [1, 2, 4, 5, 6]。int popMiddle() 将 正中间 的元素从队列中删除并返回值，如果删除之前队列为空，那么返回 -1。将 6 添加到 [1, 2, 3, 4, 5] 的中间位置，结果数组为 [1, 2, 6, 3, 4, 5]。int popFront() 将 最前面 的元素从队列中删除并返回值，如果删除之前队列为空，那么返回 -1。// 返回 1 -> [4, 3, 2]

需要注意的是，在题解中，rear指向的是插入的位置，而front指向的是队列头元素的位置，所以在插入队头元素的时候要先移动front再插入，而插入队尾元素的时候先插入再移动rear。如果操作成功返回 true ，否则返回 false。boolean isEmpty() ：若双端队列为空，则返回 true ，否则返回 false。boolean isFull() ：若双端队列满了，则返回 true ，否则返回 false。int getFront() )：从双端队列头部获得一个元素。

在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。// 返回 false，队列已满。enQueue(value): 向循环队列插入一个元素。// 返回 true。// 返回 true。// 返回 true。// 返回 true。// 返回 true。MyCircularQueue(k): 构造器，设置队列长度为 k。deQueue(): 从循环队列中删除一个元素。// 返回 true。如果队列为空，返回 -1。

而在这一题栈模拟队列中，如果使用那种做法会发现我们没办法将栈元素的排列顺序和队列类似，所以我们就只需要按栈的顺序来排列元素，然后我们在pop的时候，将栈底的元素弹出就行。那么要将栈底的元素弹出，我们就需要另外一个栈st2来辅助，我们将栈st1的元素全部推入st2中，然后st1的栈底元素就在st2的栈顶，将st2栈顶的元素pop并返回后，再将st2的元素推入st1中，这时候就可以实现st1栈底元素被pop掉。假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

栈是后进先出，队列是先进先出，所以我们需要做的就是将最后进入的元素能够放在队列的前面，由于队列是从后面推入元素，所以我们就将要推入的元素先放到队列q2中，然后再将q1的元素推入到q2，这时候要推入的元素就在队列的最前面，如果pop的话就会先pop出最后进入的元素。然后我们swap队列q1和q2，这样才能够不断循环，以队列q1为主要模拟栈，队列q2是用来辅助的。请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。// 返回 False。

我们得到的牌组顺序为 [17,13,11,2,3,5,7]（这个顺序不重要），然后将其重新排序。我们得到的牌组顺序为 [17,13,11,2,3,5,7]（这个顺序不重要），然后将其重新排序。重新排序后，牌组以 [2,13,3,11,5,17,7] 开始，其中 2 位于牌组的顶部。重新排序后，牌组以 [2,13,3,11,5,17,7] 开始，其中 2 位于牌组的顶部。牌组现在是 [3,11,5,17,7,13]。牌组现在是 [3,11,5,17,7,13]。牌组现在是 [5,17,7,13,11]。

确切地说，返回在 [t-3000, t] 内发生的请求数。// requests = [1, 100, 3001, 3002]，范围是 [2,3002]，返回 3。可以使用队列的方法，每次ping首先先记录当前请求到队列中，然后由于t是逐渐增大的，所以我们只需要将小于t-3000的t给弹出，然后返回队列q的大小即可。// requests = [1, 100, 3001]，范围是 [1,3001]，返回 3。// requests = [1]，范围是 [-2999,1]，返回 1。

那么当我们遍历3的时候，会被储存在num中，当遇到加号的时候，就会将num给push到栈中，然后将preSign更新为加号，然后遍历到5，记录到num中，然后空格跳过，接下来遇到除号，我们这时候不进行除号运算，而是进行前面preSign的运算，preSign是加号，也就是继续将5推入栈中，运算完后将preSign更新为除号，然后遍历2，记录num=2，这时候经过while循环的i++，此时i=n，触发了if判断，此时preSign为除号，将栈顶的5除以当前的num值2。输入：s = " 3/2 "

所以我们可以构建一个栈st来储存符号，我们初始化符号sign（1或-1）为1，当我们遍历字符串的时候，遇到左括号，就往栈中推入sign，推入的sign会位于栈顶，作用于这个左括号开始到右括号结束之间的符号，假设我们这时候sign是-1，然后遇到了一个左括号，然后接着在这个括号范围内遇到了一个减号，那么他就将sign变为1，也就是我们所说的负负得正，接着当我们遇到右括号的时候，就弹出栈顶的sign，因为栈顶的sign只作用于这个括号范围。输入：s = “(1+(4+5+2)-3)+(6+8)”

例如，clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1。例如，factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1。相反，我们设计了一个笨阶乘 clumsy：在整数的递减序列中，我们以一个固定顺序的操作符序列来依次替换原有的乘法操作符：乘法(*)，除法(/)，加法(+)和减法(-)。这保证结果是一个整数。解释：12 = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1。

输入：tokens = [“10”,“6”,“9”,“3”,“+”,“-11”,“该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * )。解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6。解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9。输入：tokens = [“4”,“13”,“5”,“/”,“+”]输入：tokens = [“2”,“1”,“+”,“3”,“*”]用栈可以完美模拟逆波兰表达式，过程较简单，不多解释。

首先为什么我们要向栈中推入一个-1，实际上这代表着从字符串第0个字符开始计数，然后当发现右括号找不到左括号，也就是栈st为空的时候，就将右括号坐标i填入到栈中，代表着从第i+1个元素开始计数。给你一个只包含 ‘(’ 和 ‘)’ 的字符串，找出最长有效（格式正确且连续）括号子串的长度。栈的大小在最坏情况下会达到 n，因此空间复杂度为 O(n)。，n 是给定字符串的长度。解释：最长有效括号子串是 “()()”解释：最长有效括号子串是 “()”输入：s = “)()())”输入：s = “(()”

遍历完字符串了以后，可能会存在还有未匹配的左括号，我们要做的就是将他与星号进行匹配，那么我们就记录栈顶元素，也就是他们各自的索引，由于星号这时候充当的是变成右括号，那么星号的索引必定要大于左括号才可以，如果st1的栈顶索引大于st2的栈顶索引，那么就会返回false，因为这时候找不到一个星号和这个左括号进行匹配。当我们遍历到左括号或者星号的时候，我们就将他的索引推入栈中，当我们遍历到右括号的时候，我们优先将他与左括号进行匹配，没有左括号我们才用星号去匹配。任何右括号 ‘)’ 必须有相应的左括号 ‘(’。

把匹配的全都消了，剩下的必然是 k 个 ] 加 k 个 [，k 为偶数时，交换 k/2 次就能组成 k/2 个 []，k 为奇数时，把左右两端交换后剩下 k-1 个 ] 加 k-1 个 [，再按照偶数来算，最后交换 1 + (k-1)/ 2 次组成 [[][]…解释：交换下标 0 和下标 3 对应的括号，可以使字符串变成平衡字符串。字符串可以写成 [C] ，其中 C 是一个 平衡字符串。最终字符串变成 “[[]]”。输入：s = “]]][[[”输入：s = “][][”输入：s = “[]”

这道题的思路就是，我们构造一个新的字符串str，用left来记录未匹配的左括号的数量，然后遍历s，只要遍历到左括号，就推入str中，然后left++，遍历到右括号，如果left大于0，则推入str中，令left–。这样子构造出的字符串str，可能会出现在字符串的右边，可能会有未匹配的左括号存在，所以我们从右往左遍历字符串str，删除掉多余的left即可。解释：“lee(t(co)de)” , “lee(t©ode)” 也是一个可行答案。可以被写作 (A) 的字符串，其中 A 是一个有效的「括号字符串」

由于一个左括号对应一个右括号，那么我们在遍历字符串s的时候，如果遍历到左括号，那么就往栈中推入0，当推入右括号的时候，匹配对应的左括号，当这对括号是深度最深的括号的时候，那么他们的分数就是1，否则就将分数乘以2，加到浅一层深度的左括号中。我们通过这种方法，可以找到从左往右第二个左括号和第一个右括号形成一个括号对，然后深度是1，最终他贡献的分数就是2，然后从左往右第四个左括号和他右边的右括号形成一个括号对，深度是2，最终他贡献的分数就是4。举个例子：输入： “(()(()))”输入： “(()(()))”

让我们来模拟，当遍历s到第一个左括号的时候，他根据pair记录，查找到最外层有括号位置，然后遍历方向改变成向左，这时候遇到i，ret = “i”，然后遍历到内层有括号，索引转换到最内层左括号，方向向右，这时候一一推入’l’,‘o’,‘v’,‘e’，此时ret = “ilove”，然后遇到内层有括号，他根据pair将索引转换到内层左括号，方向向左，然后加入元素’u’，此时ret就是"iloveu"。预处理出括号的对应关系的序列的时间复杂度为 O(n)，遍历字符串的时间复杂度同样为 O(n)。

这道题很简单，我们用left来记录左括号的数量，然后每当遍历到一个右括号，就会匹配一个左括号，然后令未匹配的左括号数量–，我们通过res来记录未匹配左括号的最多的数量，res即是括号的最大嵌套深度。嵌套深度是嵌套括号的 最大 数量。s 由数字 0-9 和字符 ‘+’、‘-’、‘*’、‘/’、‘(’、‘)’ 组成。输入：s = “(1+(2*3)+((8)/4))+1”输入：s = “(1)+((2))+(((3)))”输入：s = “()(())((()()))”解释：数字 3 在嵌套的 3 层括号中。

输入字符串为 “(()())(())(()(()))”，原语化分解得到 “(()())” + “(())” + “(()(()))”，删除每个部分中的最外层括号后得到 “()()” + “()” + “()(())” = “()()()()(())”。输入字符串为 “(()())(())”，原语化分解得到 “(()())” + “(())”，例如，“”，“()”，“(())()” 和 “(()(()))” 都是有效的括号字符串。输入：s = “(()())(())(()(()))”输出：“()()()”

我们可以通过一个变量leftCount来记录未匹配左括号的个数，当遍历到左括号的时候，令leftCount++，当遍历到的元素是右括号的时候，如果在他左边有未匹配的左括号，则令他们匹配，然后leftCount–，否则右括号没有被匹配，我们将未匹配的右括号个数加入到ans中。最后遍历完后，我们需要添加括号的次数就是未匹配的左括号次数加上未匹配的右括号次数。例如，如果 s = “()))” ，你可以插入一个左括号变成 “(()))”，或者插入一个右括号变成 “())))”。输入：s = “())”

我们可以采用模拟栈，定义一个数组st，我们开始遍历数组s，如果遍历的元素是左括号，那么就直接推入栈中，如果推入的是右括号，我们就看栈顶是否是对应的左括号，如果不对应的话，可以直接说明这个字符串是无效的。如果对应的话，就删除他们，对应操作是弹出栈顶元素，当我们遍历完字符串s，如果里面的括号都一一对应，那么最后栈将会是空的，如果st中还存在元素，则说明字符串s是无效字符串。给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。输入：s = “()[]{}”

该while是贪心的思想的核心，我们因为已经假设ab的得分较大，那么当遍历字符是a的时候，我们直接记录a的数量，当字符是b的时候，并且在该部分字符串中，依旧存在a，那么他们就最终能构成字符串"ab"。我们记录完删除"ab"得到的得分后，还要记录删除"ba"得到的得分，这取决于在删除完"ab"操作后，剩余的a和b的数量的较小值乘以y。然后再定义一个栈st2，遍历处理过一遍的字符串st1，遍历里面的字符，逐一删除掉较小的分的字符串，并加上相应的得分。首先核心思路不变，先删除得分较大的字符串。

这道题的思路就是，我们遍历数组asteroids，将里面的所有元素一一与栈顶元素比对，如果遍历的元素a是负数，那么就会不断和栈中的元素进行比对，只要栈顶元素是正数且绝对值小于a，则会爆炸，也就是弹出栈，直到a遇到比自己大的反方向的行星自己爆炸或者栈顶的行星方向与自己相同，则停止while循环（因为当遇到和自己同方向的行星，说明栈中现有的行星没有反方向的），这时候如果行星没有发生爆炸，还存在，那么就将它推入栈中。碰撞规则：两个小行星相互碰撞，较小的小行星会爆炸。解释：2 和 -5 发生碰撞后剩下 -5。

我们采用贪心的思想，实际上R和L相撞，也就是两个车停下，碰撞+2，R或L和S相撞，也就是一个车停下，碰撞+1。所以也就是，除了开头为L和结尾为R的不会影响结果的车，其他L和R的车的数量一定会碰撞并且停下，那么碰撞数量就是这些L和R的车的总和。我们在代码开头，用两个while将指针跳过不影响结果的元素，然后统计L和R的数量，最终结果就是碰撞数。碰撞发生后，涉及的车辆将无法继续移动并停留在碰撞位置。因此，将会在道路上发生的碰撞总次数是 0。当一辆移动的车和一辆静止的车相撞时，碰撞次数加 1。

我们定义一个栈counts，栈顶元素来表示目前构造后的字符串的最右边元素的数量，在构造过程中，只要j等于0或者推入元素和字符串最右边元素不一样，则令counts栈顶新推入1代表该元素连续的数量。我们可以通过模拟栈的方法，在每层栈元素中，储存字符和其数量，我们在遍历字符串s的时候，如果推入元素和栈顶元素相同，则数量+1，然后检查是否数量等于k，如果等于则将该层栈元素弹出，否则推入目前遍历的字符并且令数量为1。先删除 “eee” 和 “ccc”，得到 “ddbbbdaa”最后删除 “ddd”，得到 “aa”

我们定义一个变量i来记录在构造完美数组中的索引，当i为偶数的时候，我们就让原数组的元素为preNum，如果当i为奇数，并且nums不等于preNum的时候，那么我们可以将num放到i位置，然后我们让i++指向下一个位置。解释：可以删除 nums[0] 或 nums[1] ，这样得到的 nums = [1,2,3,5] 是一个美丽数组。解释：可以删除 nums[0] 和 nums[5] ，这样得到的 nums = [1,2,2,3] 是一个美丽数组。输入：nums = [1,1,2,2,3,3]

我们可以采用模拟栈的方法，由于一开始t字符串第一次操作后一定是"abc"，所以我们可以一旦遇到abc，就将它消除。在栈中表现为如果栈顶三个元素为"abc"，那么就将它弹出，最后如果st变为空，则说明可以通过将字符串 “abc” 插入到 t 中的任意位置，得到字符串s。将字符串 “abc” 插入到 t 中的任意位置。形式上，t 变为 tleft + “abc” + tright，其中 t == tleft + tright。解释：执行操作无法得到 “abccba”。因此，“aabcbc” 有效。

我们采用模拟栈的方法，我们判断栈顶元素和当前元素是不是相同字母互为大小写，我们只需要将他们都使用tolower函数变成小写字母，并且如果他们不相等，则说明他们互为大小写的相同字母，这时候我们就弹出栈顶元素，否则就推入当前元素。解释：无论你第一次选的是 i = 1 还是 i = 2，都会使 “leEeetcode” 缩减为 “leetcode”。若 s[i] 是小写字符，则 s[i+1] 不可以是相同的大写字符。若 s[i] 是大写字符，则 s[i+1] 不可以是相同的小写字符。输入：s = “s”

例如，在 “abbaca” 中，我们可以删除 “bb” 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 “aaca”，其中又只有 “aa” 可以执行重复项删除操作，所以最后的字符串为 “ca”。我们可以采用模拟栈的方法，如果栈顶元素和要推入的元素相同，则不推入元素且弹出栈顶元素。，取决于使用的语言提供的字符串类是否提供了类似「入栈」和「出栈」的接口。给出由小写字母组成的字符串 s，重复项删除操作会选择两个相邻且相同的字母，并删除它们。，其中 n 是字符串的长度。

我们可以通过模拟栈的方法，当栈顶元素为B且栈顶第二个元素为A或栈顶元素为D且栈顶第二个元素为C的时候，就将他们弹出，然后遍历完字符串s后，记录模拟栈的大小即可。你可以对此字符串执行一些操作，在每一步操作中，你可以从 s 中删除 任一个 “AB” 或 “CD” 子字符串。通过执行操作，删除所有 “AB” 和 “CD” 子串，返回可获得的最终字符串的 最小 可能长度。注意，删除子串后，重新连接出的字符串可能会产生新的 “AB” 或 “CD” 子串。，其中 n 是字符串 s 的长度。输入：s = “ACBBD”

在push函数中，我们让freq[val]++代表这个元素出现的频率增加了一次，st[freq[val]].push(val)，代表我们在储存频率为freq[val]的栈中加入元素val。//返回 4 ，因为 4, 5 和 7 出现频率最高，但 4 是最接近顶部的。堆栈变成 [5,7,5,7,4]。输出：[null,null,null,null,null,null,null,5,7,5,4]//堆栈是 [5,7,5,7,4,5]//堆栈是 [5,7,5,7,4]//堆栈是 [5,7,5,7]

我们可以思考，将t想象成一个栈，先进后出，然后当栈顶元素的值，也就是t的末尾的值比字符串s中的任何一个字符都要小的时候，那么我们就要将栈顶元素推入p中，也就是写出来的字符串，这样才能保证最小字典序列。，由于0代表a，1代表b…执行第一个操作四次，得到 p=“” ，s=“” ，t=“bdda”。执行第一个操作三次，得到 p=“” ，s=“” ，t=“zza”。执行第一个操作，得到 p=“ab” ，s=“” ，t=“c”。执行第二个操作，得到 p=“abc” ，s=“” ，t=“”。

第二次将前k+3个元素增加了val2，也就是add[k+2]=val2，那么他们共同覆盖的范围是不是前k+1个元素，那么也就是说，前k+1个元素增量是val1+val2，在第k+2到k+3个元素，增量是val2。这时候假设我们进行三次pop()操作，那么stk[k+2] += add[k+2]，然后add[k+2]将增量传给add[k+1]（使用+=），这时候stk[k+1] += add[k+1]，依旧是加上val2。// 返回 2 --> 返回栈顶值 2，栈变为 [1]// 栈变为 [1, 2, 3]

由于是栈是先进后出的原则，每次push的时候，我们要把元素push到x_stack中，然后将最小栈的栈顶元素和当前元素比较，push最小的元素，所以最小栈的栈顶始终是x_stack中的最小元素。：对于题目中的所有操作，时间复杂度均为 O(1)。因为栈的插入、删除与读取操作都是 O(1)，我们定义的每个操作最多调用栈操作两次。最坏情况下，我们会连续插入 n 个元素，此时两个栈占用的空间为 O(n)。设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。--> 返回 -3.

我们按顺序遍历字符串，在遍历过程中，如果字符不为*，那么就在栈数组对应的栈推入这个字符的位置。在循环字符串s的过程中，字符不为星号，则让mask对应位置变为1，说明这个字母存在。我们查找到字典序最小的字符所处的栈后，栈顶的元素代表这当前最靠右的字符的位置，我们在字符串s中将这个字符。：O(n+∣Σ∣)，其中 n 是 s 的长度，∣Σ∣ 为字符集合的大小，本题字符均为小写字母，所以 ∣Σ∣=26。：O(n∣Σ∣)，其中 n 是 s 的长度，∣Σ∣ 为字符集合的大小，本题字符均为小写字母，所以 ∣Σ∣=26。

的话，就将stack的栈顶元素弹出，如果是”."的话，就不进行操作，如果都不是，就推入stack中。给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格 绝对路径 （以 ‘/’ 开头），请你将其转化为 更加简洁的规范路径。所以我们就可以通过i来索引path中的元素，当path[i]为’/‘的时候，就跳过，让i指向’/‘后的第一个字母。任意多个连续的斜杠（即，‘//’ 或 ‘///’）都被视为单个斜杠 ‘/’。path 由英文字母，数字，‘.’，‘/’ 或 ‘_’ 组成。

给定 pushed 和 popped 两个序列，每个序列中的 值都不重复，只有当它们可能是在最初空栈上进行的推入 push 和弹出 pop 操作序列的结果时，返回 true；这道题的意思是，我们依次将pushed数组的元素push到栈中，如果栈顶元素刚好等于popped中的第j个元素，那么就会执行pop的操作，然后j++。输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]

使用栈的方法来模拟这个过程，当s中的字符不是* 的时候，就推入res末尾，如果是*的话，并且如果res不是空的，那么就弹出res的末尾字符。移除星号 左侧 最近的那个 非星号 字符，并移除该星号自身。解释：整个字符串都会被移除，所以返回空字符串。生成的输入保证总是可以执行题面中描述的操作。给你一个包含若干星号 * 的字符串 s。输入：s = “leet**cod*e”e" 中的 ‘t’ ，s 变为 "lee。输入：s = “erase*****”返回移除 所有 星号之后的字符串。选中 s 中的一个星号。

比赛开始时，记录是空白的。“+” - 记录加 9 + 5 = 14 ，记录现在是 [5, -2, -4, 9, 5, 14]“+” - 记录加 -4 + 9 = 5 ，记录现在是 [5, -2, -4, 9, 5]输入：ops = [“5”,“-2”,“4”,“C”,“D”,“9”,“+”,“+”]“D” - 记录加 2 * -2 = -4 ，记录现在是 [5, -2, -4]“9” - 记录加 9 ，记录现在是 [5, -2, -4, 9]输入：ops = [“5”,“2”,“C”,“D”,“+”]