diff --git a/problems/0020.有效的括号.md b/problems/0020.有效的括号.md
index 213d61b7..045c79ee 100644
--- a/problems/0020.有效的括号.md
+++ b/problems/0020.有效的括号.md
@@ -39,12 +39,13 @@
 * 输入: "{[]}"
 * 输出: true
 
-# 思路
+## 算法公开课
 
-《代码随想录》算法视频公开课：[栈的拿手好戏！| LeetCode：20. 有效的括号](https://www.bilibili.com/video/BV1AF411w78g)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[栈的拿手好戏！| LeetCode：20. 有效的括号](https://www.bilibili.com/video/BV1AF411w78g)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
 
+## 思路
 
-## 题外话
+### 题外话
 
 **括号匹配是使用栈解决的经典问题。**
 
@@ -68,7 +69,7 @@ cd a/b/c/../../
 
 这里我就不过多展开了，先来看题。
 
-## 进入正题
+### 进入正题
 
 由于栈结构的特殊性，非常适合做对称匹配类的题目。
 
@@ -143,8 +144,8 @@ public:
 
 ## 其他语言版本
 
+### Java：
 
-Java：
 ```Java
 class Solution {
     public boolean isValid(String s) {
@@ -171,7 +172,8 @@ class Solution {
 }
 ```
 
-Python：
+### Python：
+
 ```python
 # 方法一，仅使用栈，更省空间
 class Solution:
@@ -213,7 +215,8 @@ class Solution:
         return True if not stack else False
 ```
 
-Go：
+### Go：
+
 ```Go
 func isValid(s string) bool {
     hash := map[byte]byte{')':'(', ']':'[', '}':'{'}
@@ -235,7 +238,8 @@ func isValid(s string) bool {
 }
 ```
 
-Ruby:
+### Ruby:
+
 ```ruby
 def is_valid(strs)
     symbol_map = {')' => '(', '}' => '{', ']' => '['}
@@ -253,7 +257,8 @@ def is_valid(strs)
 end
 ```
 
-Javascript:
+### Javascript:
+
 ```javascript
 var isValid = function (s) {
   const stack = [];
@@ -296,7 +301,7 @@ var isValid = function(s) {
 };
 ```
 
-TypeScript:
+### TypeScript:
 
 版本一：普通版
 
@@ -348,7 +353,7 @@ function isValid(s: string): boolean {
 };
 ```
 
-Swift
+### Swift:
 
 ```swift
 func isValid(_ s: String) -> Bool {
@@ -373,7 +378,8 @@ func isValid(_ s: String) -> Bool {
 }
 ```
 
-C:
+### C:
+
 ```C
 //辅助函数：判断栈顶元素与输入的括号是否为一对。若不是，则返回False
 int notMatch(char par, char* stack, int stackTop) {
@@ -414,8 +420,8 @@ bool isValid(char * s){
 }
 ```
 
+### C#:
 
-C#:
 ```csharp
 public class Solution {
     public bool IsValid(string s) {
@@ -447,7 +453,8 @@ public class Solution {
 }
 ```
 
-PHP:
+### PHP:
+
 ```php
 // https://www.php.net/manual/zh/class.splstack.php
 class Solution
@@ -475,8 +482,8 @@ class Solution
 }
 ```
 
+### Scala:
 
-Scala:
 ```scala
 object Solution {
   import scala.collection.mutable
@@ -499,7 +506,7 @@ object Solution {
 }
 ```
 
-rust:
+### Rust:
 
 ```rust
 impl Solution {
diff --git a/problems/0150.逆波兰表达式求值.md b/problems/0150.逆波兰表达式求值.md
index 09cc4f96..663a68ea 100644
--- a/problems/0150.逆波兰表达式求值.md
+++ b/problems/0150.逆波兰表达式求值.md
@@ -5,8 +5,6 @@
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
 
-
-
 > 这不仅仅是一道好题，也展现出计算机的思考方式
 
 # 150. 逆波兰表达式求值
@@ -63,9 +61,13 @@
 
 * 适合用栈操作运算：遇到数字则入栈；遇到运算符则取出栈顶两个数字进行计算，并将结果压入栈中。
 
-# 思路
+## 算法公开课
 
-《代码随想录》算法视频公开课：[栈的最后表演！ | LeetCode：150. 逆波兰表达式求值](https://www.bilibili.com/video/BV1kd4y1o7on)，相信结合视频再看本篇题解，更有助于大家对本题的理解。
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[栈的最后表演！ | LeetCode：150. 逆波兰表达式求值](https://www.bilibili.com/video/BV1kd4y1o7on)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
+## 思路
+
+### 正题
 
 在上一篇文章中[1047.删除字符串中的所有相邻重复项](https://programmercarl.com/1047.删除字符串中的所有相邻重复项.html)提到了 递归就是用栈来实现的。
 
@@ -117,7 +119,7 @@ public:
 * 空间复杂度: O(n)
 
 
-## 题外话
+### 题外话
 
 我们习惯看到的表达式都是中缀表达式，因为符合我们的习惯，但是中缀表达式对于计算机来说就不是很友好了。
 
@@ -134,11 +136,9 @@ public:
 > During the 1970s and 1980s, Hewlett-Packard used RPN in all of their desktop and hand-held calculators, and continued to use it in some models into the 2020s.
 
 
-
-
 ## 其他语言版本
 
-java:
+### Java:
 
 ```Java
 class Solution {
@@ -164,7 +164,7 @@ class Solution {
 }
 ```
 
-python3
+### Python3：
 
 ```python
 from operator import add, sub, mul
@@ -201,7 +201,8 @@ class Solution:
 
 ```
 
-Go:
+### Go:
+
 ```Go
 func evalRPN(tokens []string) int {
 	stack := []int{}
@@ -228,7 +229,7 @@ func evalRPN(tokens []string) int {
 }
 ```
 
-javaScript:
+### JavaScript:
 
 ```js
 var evalRPN = function (tokens) {
@@ -259,7 +260,7 @@ var evalRPN = function (tokens) {
 };
 ```
 
-TypeScript：
+### TypeScript：
 
 普通版：
 
@@ -324,7 +325,8 @@ function evalRPN(tokens: string[]): number {
 };
 ```
 
-Swift：
+### Swift：
+
 ```Swift
 func evalRPN(_ tokens: [String]) -> Int {
     var stack = [Int]()
@@ -357,7 +359,8 @@ func evalRPN(_ tokens: [String]) -> Int {
 }
 ```
 
-C#:
+### C#:
+
 ```csharp
 public int EvalRPN(string[] tokens) {
         int num;
@@ -391,8 +394,8 @@ public int EvalRPN(string[] tokens) {
     }
 ```
 
+### PHP：
 
-PHP：
 ```php
 class Solution {
     function evalRPN($tokens) {
@@ -417,7 +420,8 @@ class Solution {
 }
 ```
 
-Scala:
+### Scala:
+
 ```scala
 object Solution {
   import scala.collection.mutable
@@ -447,7 +451,7 @@ object Solution {
 }
 ```
 
-rust:
+### Rust:
 
 ```rust
 impl Solution {
diff --git a/problems/0225.用队列实现栈.md b/problems/0225.用队列实现栈.md
index 94c79404..13b742f8 100644
--- a/problems/0225.用队列实现栈.md
+++ b/problems/0225.用队列实现栈.md
@@ -25,11 +25,11 @@
 * 你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
 * 你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。
 
+## 算法公开课
 
-# 思路
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[队列的基本操作！ | LeetCode：225. 用队列实现栈](https://www.bilibili.com/video/BV1Fd4y1K7sm)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
 
-
-《代码随想录》算法公开课：[队列的基本操作！ | LeetCode：225. 用队列实现栈](https://www.bilibili.com/video/BV1Fd4y1K7sm)，相信结合视频再看本篇题解，更有助于大家对链表的理解。
+## 思路
 
 
 （这里要强调是单向队列）
@@ -114,7 +114,7 @@ public:
 * 时间复杂度: push为O(n)，其他为O(1)
 * 空间复杂度: O(n)
 
-# 优化
+## 优化
 
 其实这道题目就是用一个队列就够了。
 
@@ -162,9 +162,9 @@ public:
 * 空间复杂度: O(n)
 
 
-# 其他语言版本
+## 其他语言版本
 
-Java：
+### Java：
 
 使用两个 Queue 实现方法1
 ```java
@@ -404,7 +404,7 @@ class MyStack {
 }
 ```
 
-Python：
+### Python：
 
 ```python
 from collections import deque
@@ -496,8 +496,7 @@ class MyStack:
         return not self.que
 ```
 
-
-Go：
+### Go：
 
 使用两个队列实现
 ```go
@@ -628,9 +627,7 @@ func (this *MyStack) Empty() bool {
  */
 ```
 
-
-
-javaScript: 
+### JavaScript: 
 
 使用数组（push, shift）模拟队列
 
@@ -740,7 +737,7 @@ MyStack.prototype.empty = function() {
 
 ```
 
-TypeScript:
+### TypeScript:
 
 版本一：使用两个队列模拟栈
 
@@ -812,7 +809,7 @@ class MyStack {
 }
 ```
 
-Swift
+### Swift:
 
 ```Swift
 // 定义一个队列数据结构
@@ -931,8 +928,9 @@ class MyStack {
     }
 }
 ```
-Scala:
+### Scala:
 使用两个队列模拟栈:
+
 ```scala
 import scala.collection.mutable
 
@@ -1015,8 +1013,8 @@ class MyStack() {
   }
 ```
 
+### C#:
 
-C#:
 ```csharp
 public class MyStack {
     Queue<int> queue1;
@@ -1051,8 +1049,9 @@ public class MyStack {
 }
 ```
 
-PHP
-> 双对列
+### PHP:
+
+> 双队列
 ```php
 // SplQueue 类通过使用一个双向链表来提供队列的主要功能。(PHP 5 >= 5.3.0, PHP 7, PHP 8)
 // https://www.php.net/manual/zh/class.splqueue.php
@@ -1130,6 +1129,8 @@ class MyStack {
 }
 ```
 
+### Rust:
+
 > rust：单队列
 
 ```rust
diff --git a/problems/0232.用栈实现队列.md b/problems/0232.用栈实现队列.md
index 4a57ee96..c510fc12 100644
--- a/problems/0232.用栈实现队列.md
+++ b/problems/0232.用栈实现队列.md
@@ -36,11 +36,12 @@ queue.empty(); // 返回 false
 * 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
 * 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）。
 
+## 算法公开课
+
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[栈的基本操作！ | LeetCode：232.用栈实现队列](https://www.bilibili.com/video/BV1nY4y1w7VC)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
 ## 思路
 
-《代码随想录》算法公开课：[栈的基本操作！ | LeetCode：232.用栈实现队列](https://www.bilibili.com/video/BV1nY4y1w7VC)，相信结合视频再看本篇题解，更有助于大家对栈和队列的理解。
-
-
 这是一道模拟题，不涉及到具体算法，考察的就是对栈和队列的掌握程度。
 
 使用栈来模式队列的行为，如果仅仅用一个栈，是一定不行的，所以需要两个栈**一个输入栈，一个输出栈**，这里要注意输入栈和输出栈的关系。
@@ -132,7 +133,7 @@ public:
 
 ## 其他语言版本
 
-Java：
+### Java：
 
 ```java
 class MyQueue {
@@ -179,8 +180,8 @@ class MyQueue {
 
 ```
 
+### Python：
 
-Python：
 ```python
 class MyQueue:
 
@@ -231,8 +232,8 @@ class MyQueue:
 
 ```
 
+### Go：
 
-Go：
 ```Go
 type MyQueue struct {
     stackIn  []int //输入栈
@@ -283,7 +284,7 @@ func (this *MyQueue) Empty() bool {
 }
 ```
 
- javaScript:
+### JavaScript:
 
  ```js
  // 使用两个数组的栈方法（push, pop） 实现队列
@@ -338,7 +339,7 @@ MyQueue.prototype.empty = function() {
 };
  ```
 
-TypeScript:
+### TypeScript:
 
 ```typescript
 class MyQueue {
@@ -374,7 +375,7 @@ class MyQueue {
 }
 ```
 
-Swift：
+### Swift：
 
 ```swift
 class MyQueue {
@@ -413,7 +414,8 @@ class MyQueue {
 }
 ```
 
-C:
+### C:
+
 ```C
 /*
 1.两个type为int的数组（栈），大小为100
@@ -490,8 +492,8 @@ void myQueueFree(MyQueue* obj) {
 }
 ```
 
+### C#:
 
-C#:
 ```csharp
 public class MyQueue {
     Stack<int> inStack;
@@ -534,7 +536,8 @@ public class MyQueue {
 
 
 
-PHP:
+### PHP:
+
 ```php
 // SplStack 类通过使用一个双向链表来提供栈的主要功能。[PHP 5 >= 5.3.0, PHP 7, PHP 8]
 // https://www.php.net/manual/zh/class.splstack.php
@@ -579,7 +582,8 @@ class MyQueue {
     }
 ```
 
-Scala:
+### Scala:
+
 ```scala
 class MyQueue() {
   import scala.collection.mutable
@@ -621,7 +625,7 @@ class MyQueue() {
 }
 ```
 
-rust:
+### Rust:
 
 ```rust
 struct MyQueue {
@@ -666,4 +670,3 @@ impl MyQueue {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
-
diff --git a/problems/0239.滑动窗口最大值.md b/problems/0239.滑动窗口最大值.md
index f1c4b76c..6f420479 100644
--- a/problems/0239.滑动窗口最大值.md
+++ b/problems/0239.滑动窗口最大值.md
@@ -28,11 +28,11 @@
 * -10^4 <= nums[i] <= 10^4
 * 1 <= k <= nums.length
 
+## 算法公开课
 
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[单调队列正式登场！| LeetCode：239. 滑动窗口最大值](https://www.bilibili.com/video/BV1XS4y1p7qj)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
 
-# 思路
-
-《代码随想录》算法视频公开课：[单调队列正式登场！| LeetCode：239. 滑动窗口最大值](https://www.bilibili.com/video/BV1XS4y1p7qj)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
+## 思路
 
 这是使用单调队列的经典题目。
 
@@ -196,7 +196,7 @@ public:
 
 空间复杂度因为我们定义一个辅助队列，所以是O(k)。
 
-# 扩展
+## 扩展
 
 大家貌似对单调队列 都有一些疑惑，首先要明确的是，题解中单调队列里的pop和push接口，仅适用于本题哈。单调队列不是一成不变的，而是不同场景不同写法，总之要保证队列里单调递减或递增的原则，所以叫做单调队列。 不要以为本题中的单调队列实现就是固定的写法哈。
 
@@ -204,10 +204,10 @@ public:
 
 
 
-# 其他语言版本
+## 其他语言版本
 
+### Java：
 
-Java：
 ```Java
 //解法一
 //自定义数组
@@ -298,7 +298,8 @@ class Solution {
 }
 ```
 
-Python：
+### Python：
+
 ```python
 from collections import deque
 
@@ -338,8 +339,7 @@ class Solution:
         return result
 ```
 
-
-Go：
+### Go：
 
 ```go
 // 封装单调队列的方式解题
@@ -401,7 +401,8 @@ func maxSlidingWindow(nums []int, k int) []int {
 }
 ```
 
-Javascript:
+### Javascript:
+
 ```javascript
 /**
  * @param {number[]} nums
@@ -449,7 +450,7 @@ var maxSlidingWindow = function (nums, k) {
 };
 ```
 
-TypeScript：
+### TypeScript：
 
 ```typescript
 function maxSlidingWindow(nums: number[], k: number): number[] {
@@ -497,7 +498,9 @@ function maxSlidingWindow(nums: number[], k: number): number[] {
 };
 ```
 
-Swift:
+### Swift:
+
+解法一:
 
 ```Swift
 /// 双向链表
@@ -638,7 +641,8 @@ func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
     return result
 }
 ```
-Scala:
+### Scala:
+
 ```scala
 import scala.collection.mutable.ArrayBuffer
 object Solution {
@@ -686,8 +690,8 @@ class MyQueue {
 }
 ```
 
+### PHP:
 
-PHP:
 ```php
 class Solution {
     /**
@@ -764,7 +768,8 @@ class MyQueue{
 }
 ```
 
-C#:
+### C#:
+
 ```csharp
 class myDequeue{
         private LinkedList<int> linkedList = new LinkedList<int>();
@@ -805,7 +810,7 @@ class myDequeue{
     }
 ```
 
-rust:
+### Rust:
 
 ```rust
 impl Solution {
diff --git a/problems/0347.前K个高频元素.md b/problems/0347.前K个高频元素.md
index 6c8b51b1..b3063111 100644
--- a/problems/0347.前K个高频元素.md
+++ b/problems/0347.前K个高频元素.md
@@ -5,8 +5,6 @@
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
 
-
-
 > 前K个大数问题，老生常谈，不得不谈
 
 # 347.前 K 个高频元素
@@ -29,9 +27,11 @@
 * 题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。
 * 你可以按任意顺序返回答案。
 
-# 思路
+## 算法公开课
 
-《代码随想录》算法视频公开课：[优先级队列正式登场！大顶堆、小顶堆该怎么用？| LeetCode：347.前 K 个高频元素](https://www.bilibili.com/video/BV1Xg41167Lz)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[优先级队列正式登场！大顶堆、小顶堆该怎么用？| LeetCode：347.前 K 个高频元素](https://www.bilibili.com/video/BV1Xg41167Lz)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
+## 思路
 
 这道题目主要涉及到如下三块内容：
 1. 要统计元素出现频率
@@ -122,7 +122,7 @@ public:
 * 时间复杂度: O(nlogk)
 * 空间复杂度: O(n)
 
-# 拓展
+## 拓展
 大家对这个比较运算在建堆时是如何应用的，为什么左大于右就会建立小顶堆，反而建立大顶堆比较困惑。
 
 确实 例如我们在写快排的cmp函数的时候，`return left>right` 就是从大到小，`return left<right` 就是从小到大。
@@ -130,10 +130,10 @@ public:
 优先级队列的定义正好反过来了，可能和优先级队列的源码实现有关（我没有仔细研究），我估计是底层实现上优先队列队首指向后面，队尾指向最前面的缘故！
 
 
-# 其他语言版本
+## 其他语言版本
 
+### Java：
 
-Java：
 ```java
 
 /*Comparator接口说明:
@@ -216,7 +216,8 @@ class Solution {
 }
 ```
 
-Python：
+### Python：
+
 ```python
 #时间复杂度：O(nlogk)
 #空间复杂度：O(n)
@@ -245,7 +246,7 @@ class Solution:
         return result
 ```
 
-Go：
+### Go：
 
 ```go
 //方法一：小顶堆
@@ -320,8 +321,8 @@ func topKFrequent(nums []int, k int) []int {
 
 
 
+### JavaScript:
 
-JavaScript:
 ```js
 // js 没有堆 需要自己构造
 class Heap {
@@ -419,7 +420,7 @@ const topKFrequent = function (nums, k) {
 };
 ```
 
-TypeScript：
+### TypeScript：
 
 ```typescript
 function topKFrequent(nums: number[], k: number): number[] {
@@ -435,7 +436,8 @@ function topKFrequent(nums: number[], k: number): number[] {
 };
 ```
 
-C#:
+### C#:
+
 ```csharp
  public int[] TopKFrequent(int[] nums, int k) {
         //哈希表-标权重
@@ -473,7 +475,7 @@ C#:
     
 ```
 
-Scala:
+### Scala:
 
 解法一: 优先级队列
 ```scala
@@ -517,7 +519,9 @@ object Solution {
 }
 ```
 
-rust: 小根堆
+### Rust
+
+小根堆
 
 ```rust
 use std::cmp::Reverse;
@@ -549,3 +553,4 @@ impl Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+
diff --git a/problems/1047.删除字符串中的所有相邻重复项.md b/problems/1047.删除字符串中的所有相邻重复项.md
index 486d198b..ad54f0f8 100644
--- a/problems/1047.删除字符串中的所有相邻重复项.md
+++ b/problems/1047.删除字符串中的所有相邻重复项.md
@@ -5,8 +5,6 @@
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
 
-
-
 > 匹配问题都是栈的强项
 
 # 1047. 删除字符串中的所有相邻重复项
@@ -30,11 +28,13 @@
 * 1 <= S.length <= 20000
 * S 仅由小写英文字母组成。
 
-# 思路
+## 算法公开课
 
-《代码随想录》算法视频公开课：[栈的好戏还要继续！| LeetCode：1047. 删除字符串中的所有相邻重复项](https://www.bilibili.com/video/BV12a411P7mw)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[栈的好戏还要继续！| LeetCode：1047. 删除字符串中的所有相邻重复项](https://www.bilibili.com/video/BV12a411P7mw)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
 
-## 正题
+## 思路
+
+### 正题
 
 本题要删除相邻相同元素，相对于[20. 有效的括号](https://programmercarl.com/0020.%E6%9C%89%E6%95%88%E7%9A%84%E6%8B%AC%E5%8F%B7.html)来说其实也是匹配问题，20. 有效的括号 是匹配左右括号，本题是匹配相邻元素，最后都是做消除的操作。 
 
@@ -105,7 +105,7 @@ public:
 * 时间复杂度: O(n)
 * 空间复杂度: O(1)，返回值不计空间复杂度
 
-## 题外话
+### 题外话
 
 这道题目就像是我们玩过的游戏对对碰，如果相同的元素挨在一起就要消除。
 
@@ -125,8 +125,7 @@ public:
 
 ## 其他语言版本
 
-
-Java：
+### Java：
 
 使用 Deque 作为堆栈
 ```Java
@@ -203,7 +202,8 @@ class Solution {
 }
 ```
 
-Python：
+### Python：
+
 ```python
 # 方法一，使用栈
 class Solution:
@@ -239,7 +239,7 @@ class Solution:
         return ''.join(res[0: slow])
 ```
 
-Go：
+### Go：
 
 ```go
 func removeDuplicates(s string) string {
@@ -258,7 +258,7 @@ func removeDuplicates(s string) string {
 }
 ```
 
-javaScript: 
+### JavaScript: 
 
 法一：使用栈
 
@@ -295,7 +295,7 @@ var removeDuplicates = function(s) {
 };
 ```
 
-TypeScript：
+### TypeScript：
 
 ```typescript
 function removeDuplicates(s: string): string {
@@ -318,7 +318,7 @@ function removeDuplicates(s: string): string {
 };
 ```
 
-C:
+### C:
 方法一：使用栈
 
 ```c
@@ -371,7 +371,8 @@ char * removeDuplicates(char * s){
 }
 ```
 
-Swift：
+### Swift：
+
 ```swift
 func removeDuplicates(_ s: String) -> String {
     var stack = [Character]()
@@ -386,8 +387,8 @@ func removeDuplicates(_ s: String) -> String {
 }
 ```
 
+### C#:
 
-C#:
 ```csharp
 public string RemoveDuplicates(string s) {
         //拿字符串直接作为栈，省去了栈还要转为字符串的操作
@@ -405,8 +406,8 @@ public string RemoveDuplicates(string s) {
     }
 ```
 
+### PHP:
 
-PHP:
 ```php
 class Solution {
     function removeDuplicates($s) {
@@ -431,8 +432,8 @@ class Solution {
 }
 ```
 
+### Scala:
 
-Scala:
 ```scala
 object Solution {
   import scala.collection.mutable
@@ -455,7 +456,7 @@ object Solution {
 }
 ```
 
-rust:
+### Rust:
 
 ```rust
 impl Solution {
diff --git a/problems/双指针总结.md b/problems/双指针总结.md
index 04a8cb9a..6621e039 100644
--- a/problems/双指针总结.md
+++ b/problems/双指针总结.md
@@ -8,7 +8,8 @@
 
 相信大家已经对双指针法很熟悉了，但是双指针法并不隶属于某一种数据结构，我们在讲解数组，链表，字符串都用到了双指针法，所有有必要针对双指针法做一个总结。 
 
-# 数组篇 
+# 双指针总结篇
+## 数组篇 
 
 在[数组：就移除个元素很难么？](https://programmercarl.com/0027.移除元素.html)中，原地移除数组上的元素，我们说到了数组上的元素，不能真正的删除，只能覆盖。 
 
@@ -26,7 +27,7 @@ for (int i = 0; i < array.size(); i++) {
 
 所以此时使用双指针法才展现出效率的优势：**通过两个指针在一个for循环下完成两个for循环的工作。** 
 
-# 字符串篇 
+## 字符串篇 
 
 在[字符串：这道题目，使用库函数一行代码搞定](https://programmercarl.com/0344.反转字符串.html)中讲解了反转字符串，注意这里强调要原地反转，要不然就失去了题目的意义。
 
@@ -48,7 +49,7 @@ for (int i = 0; i < array.size(); i++) {
 
 **主要还是大家用erase用的比较随意，一定要注意for循环下用erase的情况，一般可以用双指针写效率更高！**
 
-# 链表篇 
+## 链表篇 
 
 翻转链表是现场面试，白纸写代码的好题，考察了候选者对链表以及指针的熟悉程度，而且代码也不长，适合在白纸上写。
 
@@ -62,7 +63,7 @@ for (int i = 0; i < array.size(); i++) {
 
 那么找到环的入口，其实需要点简单的数学推理，我在文章中把找环的入口清清楚楚的推理的一遍，如果对找环入口不够清楚的同学建议自己看一看[链表：环找到了，那入口呢？](https://programmercarl.com/0142.环形链表II.html)。
 
-# N数之和篇
+## N数之和篇
 
 在[哈希表：解决了两数之和，那么能解决三数之和么？](https://programmercarl.com/0015.三数之和.html)中，讲到使用哈希法可以解决1.两数之和的问题
 
@@ -87,7 +88,7 @@ for (int i = 0; i < array.size(); i++) {
 同样的道理，五数之和，n数之和都是在这个基础上累加。
 
 
-# 总结 
+## 总结 
 
 本文中一共介绍了leetcode上九道使用双指针解决问题的经典题目，除了链表一些题目一定要使用双指针，其他题目都是使用双指针来提高效率，一般是将O(n^2)的时间复杂度，降为$O(n)$。
 
diff --git a/problems/栈与队列总结.md b/problems/栈与队列总结.md
index c3132201..31ce9554 100644
--- a/problems/栈与队列总结.md
+++ b/problems/栈与队列总结.md
@@ -3,9 +3,9 @@
   <img src="../pics/训练营.png" width="1000"/>
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
+# 栈与队列总结篇
 
-
-# 栈与队列的理论基础
+## 栈与队列的理论基础
 
 首先我们在[栈与队列：来看看栈和队列不为人知的一面](https://programmercarl.com/栈与队列理论基础.html)中讲解了栈和队列的理论基础。
 
@@ -37,9 +37,9 @@
 
 **一个队列在模拟栈弹出元素的时候只要将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部，此时在去弹出元素就是栈的顺序了。** 
 
-# 栈经典题目
+## 栈经典题目
 
-## 栈在系统中的应用
+### 栈在系统中的应用
 
 如果还记得编译原理的话，编译器在 词法分析的过程中处理括号、花括号等这个符号的逻辑，就是使用了栈这种数据结构。
 
@@ -59,7 +59,7 @@ cd a/b/c/../../
 
 **所以数据结构与算法的应用往往隐藏在我们看不到的地方！**
 
-## 括号匹配问题
+### 括号匹配问题
 
 在[栈与队列：系统中处处都是栈的应用](https://programmercarl.com/0020.有效的括号.html)中我们讲解了括号匹配问题。
 
@@ -75,23 +75,23 @@ cd a/b/c/../../
 
 这里还有一些技巧，在匹配左括号的时候，右括号先入栈，就只需要比较当前元素和栈顶相不相等就可以了，比左括号先入栈代码实现要简单的多了！
 
-## 字符串去重问题
+### 字符串去重问题
 
 在[栈与队列：匹配问题都是栈的强项](https://programmercarl.com/1047.删除字符串中的所有相邻重复项.html)中讲解了字符串去重问题。
 1047. 删除字符串中的所有相邻重复项
 
 思路就是可以把字符串顺序放到一个栈中，然后如果相同的话 栈就弹出，这样最后栈里剩下的元素都是相邻不相同的元素了。
 
-## 逆波兰表达式问题 
+### 逆波兰表达式问题 
 
 在[栈与队列：有没有想过计算机是如何处理表达式的？](https://programmercarl.com/0150.逆波兰表达式求值.html)中讲解了求逆波兰表达式。
 
 本题中每一个子表达式要得出一个结果，然后拿这个结果再进行运算，那么**这岂不就是一个相邻字符串消除的过程，和[栈与队列：匹配问题都是栈的强项](https://programmercarl.com/1047.删除字符串中的所有相邻重复项.html)中的对对碰游戏是不是就非常像了。** 
 
 
-# 队列的经典题目 
+## 队列的经典题目 
 
-## 滑动窗口最大值问题
+### 滑动窗口最大值问题
 
 在[栈与队列：滑动窗口里求最大值引出一个重要数据结构](https://programmercarl.com/0239.滑动窗口最大值.html)中讲解了一种数据结构：单调队列。
 
@@ -119,7 +119,7 @@ cd a/b/c/../../
 我们用deque作为单调队列的底层数据结构，C++中deque是stack和queue默认的底层实现容器（这个我们之前已经讲过），deque是可以两边扩展的，而且deque里元素并不是严格的连续分布的。
 
 
-## 求前 K 个高频元素 
+### 求前 K 个高频元素 
 
 在[栈与队列：求前 K 个高频元素和队列有啥关系？](https://programmercarl.com/0347.前K个高频元素.html)中讲解了求前 K 个高频元素。
 
@@ -143,7 +143,7 @@ cd a/b/c/../../
 
 所以排序的过程的时间复杂度是$O(\log k)$，整个算法的时间复杂度是$O(n\log k)$。
 
-# 总结
+## 总结
 
 在栈与队列系列中，我们强调栈与队列的基础，也是很多同学容易忽视的点。
 
@@ -162,3 +162,4 @@ cd a/b/c/../../
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+
diff --git a/problems/栈与队列理论基础.md b/problems/栈与队列理论基础.md
index 0075deb6..ad748e48 100644
--- a/problems/栈与队列理论基础.md
+++ b/problems/栈与队列理论基础.md
@@ -4,8 +4,11 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
+
 > 来看看栈和队列不为人知的一面
 
+# 栈与队列理论基础
+
 我想栈和队列的原理大家应该很熟悉了，队列是先进先出，栈是先进后出。
 
 如图所示：
@@ -93,3 +96,4 @@ std::queue<int, std::list<int>> third; // 定义以list为底层容器的队列
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+