diff --git a/problems/0347.前K个高频元素.md b/problems/0347.前K个高频元素.md
index 4830f9a3..94b29eba 100644
--- a/problems/0347.前K个高频元素.md
+++ b/problems/0347.前K个高频元素.md
@@ -145,43 +145,43 @@ public:
 class Solution {
     //解法1：基于大顶堆实现
     public int[] topKFrequent1(int[] nums, int k) {
-        Map<Integer,Integer> map = new HashMap<>();//key为数组元素值,val为对应出现次数
-        for(int num:nums){
-            map.put(num,map.getOrDefault(num,0)+1);
+        Map<Integer,Integer> map = new HashMap<>(); //key为数组元素值,val为对应出现次数
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num,0) + 1);
         }
-        //在优先队列中存储二元组(num,cnt),cnt表示元素值num在数组中的出现次数
+        //在优先队列中存储二元组(num, cnt),cnt表示元素值num在数组中的出现次数
         //出现次数按从队头到队尾的顺序是从大到小排,出现次数最多的在队头(相当于大顶堆)
-        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2)->pair2[1]-pair1[1]);
-        for(Map.Entry<Integer,Integer> entry:map.entrySet()){//大顶堆需要对所有元素进行排序
-            pq.add(new int[]{entry.getKey(),entry.getValue()});
+        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair2[1] - pair1[1]);
+        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {//大顶堆需要对所有元素进行排序
+            pq.add(new int[]{entry.getKey(), entry.getValue()});
         }
         int[] ans = new int[k];
-        for(int i=0;i<k;i++){//依次从队头弹出k个,就是出现频率前k高的元素
+        for (int i = 0; i < k; i++) { //依次从队头弹出k个,就是出现频率前k高的元素
             ans[i] = pq.poll()[0];
         }
         return ans;
     }
     //解法2：基于小顶堆实现
     public int[] topKFrequent2(int[] nums, int k) {
-        Map<Integer,Integer> map = new HashMap<>();//key为数组元素值,val为对应出现次数
-        for(int num:nums){
-            map.put(num,map.getOrDefault(num,0)+1);
+        Map<Integer,Integer> map = new HashMap<>(); //key为数组元素值,val为对应出现次数
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
         }
-        //在优先队列中存储二元组(num,cnt),cnt表示元素值num在数组中的出现次数
+        //在优先队列中存储二元组(num, cnt),cnt表示元素值num在数组中的出现次数
         //出现次数按从队头到队尾的顺序是从小到大排,出现次数最低的在队头(相当于小顶堆)
-        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1,pair2)->pair1[1]-pair2[1]);
-        for(Map.Entry<Integer,Integer> entry:map.entrySet()){//小顶堆只需要维持k个元素有序
-            if(pq.size()<k){//小顶堆元素个数小于k个时直接加
-                pq.add(new int[]{entry.getKey(),entry.getValue()});
-            }else{
-                if(entry.getValue()>pq.peek()[1]){//当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)
-                    pq.poll();//弹出队头(小顶堆的根结点),即把堆里出现次数最少的那个删除,留下的就是出现次数多的了
-                    pq.add(new int[]{entry.getKey(),entry.getValue()});
+        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair1[1] - pair2[1]);
+        for (Map.Entry<Integer, Integer> entry : map.entrySet()) { //小顶堆只需要维持k个元素有序
+            if (pq.size() < k) { //小顶堆元素个数小于k个时直接加
+                pq.add(new int[]{entry.getKey(), entry.getValue()});
+            } else {
+                if (entry.getValue() > pq.peek()[1]) { //当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)
+                    pq.poll(); //弹出队头(小顶堆的根结点),即把堆里出现次数最少的那个删除,留下的就是出现次数多的了
+                    pq.add(new int[]{entry.getKey(), entry.getValue()});
                 }
             }
         }
         int[] ans = new int[k];
-        for(int i=k-1;i>=0;i--){//依次弹出小顶堆,先弹出的是堆的根,出现次数少,后面弹出的出现次数多
+        for (int i = k - 1; i >= 0; i--) { //依次弹出小顶堆,先弹出的是堆的根,出现次数少,后面弹出的出现次数多
             ans[i] = pq.poll()[0];
         }
         return ans;
@@ -197,8 +197,8 @@ class Solution {
         PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> o1[1] - o2[1]);
         int[] res = new int[k]; // 答案数组为 k 个元素
         Map<Integer, Integer> map = new HashMap<>(); // 记录元素出现次数
-        for(int num : nums) map.put(num, map.getOrDefault(num, 0) + 1);
-        for(var x : map.entrySet()) { // entrySet 获取 k-v Set 集合
+        for (int num : nums) map.put(num, map.getOrDefault(num, 0) + 1);
+        for (var x : map.entrySet()) { // entrySet 获取 k-v Set 集合
             // 将 kv 转化成数组
             int[] tmp = new int[2];
             tmp[0] = x.getKey();
@@ -209,7 +209,7 @@ class Solution {
                 pq.poll();
             }
         }
-        for(int i = 0; i < k; i ++) {
+        for (int i = 0; i < k; i++) {
             res[i] = pq.poll()[0]; // 获取优先队列里的元素
         }
         return res;
diff --git a/problems/栈与队列总结.md b/problems/栈与队列总结.md
index 4e08a887..06a78270 100644
--- a/problems/栈与队列总结.md
+++ b/problems/栈与队列总结.md
@@ -115,7 +115,7 @@ cd a/b/c/../../
 
 **单调队列不是一成不变的，而是不同场景不同写法**，总之要保证队列里单调递减或递增的原则，所以叫做单调队列。 
 
-**不要以为本地中的单调队列实现就是固定的写法。**  
+**不要以为本题中的单调队列实现就是固定的写法。**  
 
 我们用deque作为单调队列的底层数据结构，C++中deque是stack和queue默认的底层实现容器（这个我们之前已经讲过），deque是可以两边扩展的，而且deque里元素并不是严格的连续分布的。