✨feat: add 1190

Author: SharingSource

LeetCode/1181-1190/1190. 反转每对括号间的子串（中等）.md

@@ -6,43 +6,45 @@ Tag : 「双端队列」、「栈」
 
 
 
-
-给出一个字符串 s（仅含有小写英文字母和括号）。
+给出一个字符串 `s`（仅含有小写英文字母和括号）。
 
 请你按照从括号内到外的顺序，逐层反转每对匹配括号中的字符串，并返回最终的结果。
 
 注意，您的结果中 不应 包含任何括号。
 
-
 示例 1：
 ```
 输入：s = "(abcd)"
+
 输出："dcba"
 ```
 示例 2：
 ```
 输入：s = "(u(love)i)"
+
 输出："iloveu"
 ```
 示例 3：
 ```
 输入：s = "(ed(et(oc))el)"
+
 输出："leetcode"
 ```
 示例 4：
 ```
 输入：s = "a(bcdefghijkl(mno)p)q"
+
 输出："apmnolkjihgfedcbq"
 ```
 
 提示：
-* 0 <= s.length <= 2000
-* s 中只有小写英文字母和括号
+* $0 <= s.length <= 2000$
+* `s` 中只有小写英文字母和括号
 * 我们确保所有括号都是成对出现的
 
 ---
 
-### 基本分析
+### 双端队列
 
 根据题意，我们可以设计如下处理流程：
 
@@ -54,16 +56,9 @@ Tag : 「双端队列」、「栈」
 
 可以发现，上述过程需要用到双端队列（或者栈，使用栈的话，需要在最后一步对取出字符串再进行一次翻转）。
 
-在 Java 中，双端队列可以使用自带的 `ArrayDeque`， 也可以直接使用数组进行模拟。
-
----
-
-### 语言自带双端队列
-
-![image.png](https://pic.leetcode-cn.com/1621991010-kJgICN-image.png)
+在 `Java` 中，双端队列可以使用自带的 `ArrayDeque`， 也可以直接使用数组进行模拟。
 
-
-代码：
+代码（使用 `ArrayDeque` ）：
 ```Java
 class Solution {
     public String reverseParentheses(String s) {
@@ -79,9 +74,7 @@ class Solution {
                         path.append(d.pollLast());
                     } else {
                         d.pollLast();
-                        for (int j = 0; j < path.length(); j++) {
-                            d.addLast(path.charAt(j));
-                        }
+                        for (int j = 0; j < path.length(); j++) d.addLast(path.charAt(j));
                         break;
                     }
                 }
@@ -95,53 +88,39 @@ class Solution {
     }
 }
 ```
-* 时间复杂度：每个 `(` 字符只会进出队列一次；`)` 字符串都不会进出队列，也只会被扫描一次；分析的重点在于普通字符，可以发现每个普通字符进出队列的次数取决于其右边的 `)` 的个数，最坏情况下每个字符右边全是右括号，因此复杂度可以当做 $O(n^2)$，但实际计算量必然取不满 $n^2$，将普通字符的重复弹出均摊到整个字符串处理过程，可以看作是每个字符串都被遍历常数次，复杂度为 $O(n)$
-* 空间复杂度：$O(n)$
-
----
-
-### 数组模拟双端队列
-
-![image.png](https://pic.leetcode-cn.com/1621993297-rtTfzz-image.png)
-
-代码：
+代码（数组模拟双端队列）：
 ```Java
 class Solution {
-    char[] deque = new char[2009];
-    int head = 0, tail = -1;
-    char[] path = new char[2009];
+    int N = 2010, he = 0, ta = 0;
+    char[] d = new char[N], path = new char[N];
     public String reverseParentheses(String s) {
         int n = s.length();
         char[] cs = s.toCharArray();
         for (int i = 0; i < n; i++) {
             char c = cs[i];
             if (c == ')') {
                 int idx = 0;
-                while (tail >= head) {
-                    if (deque[tail] == '(') {
-                        tail--;
-                        for (int j = 0; j < idx; j++) {
-                            deque[++tail] = path[j];
-                        }
+                while (he < ta) {
+                    if (d[ta - 1] == '(' && --ta >= 0) {
+                        for (int j = 0; j < idx; j++) d[ta++] = path[j];
                         break;
                     } else {
-                        path[idx++] = deque[tail--];
+                        path[idx++] = d[--ta];
                     }
                 }
             } else {
-                deque[++tail] = c;
+                d[ta++] = c;
             }
         }
         StringBuilder sb = new StringBuilder();
-        while (tail >= head) sb.append(deque[head++]);
+        while (he < ta) sb.append(d[he++]);
         return sb.toString();
     }
 }
 ```
 * 时间复杂度：每个 `(` 字符只会进出队列一次；`)` 字符串都不会进出队列，也只会被扫描一次；分析的重点在于普通字符，可以发现每个普通字符进出队列的次数取决于其右边的 `)` 的个数，最坏情况下每个字符右边全是右括号，因此复杂度可以当做 $O(n^2)$，但实际计算量必然取不满 $n^2$，将普通字符的重复弹出均摊到整个字符串处理过程，可以看作是每个字符串都被遍历常数次，复杂度为 $O(n)$
 * 空间复杂度：$O(n)$
 
-
 ---
 
 ### 最后