diff --git a/README.md b/README.md
index e4ea6961..0fc650a9 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,8 @@ LeetCode 最强题解（持续更新中）:
 |题目 | 类型 | 难度 | 解题方法 |
 |---|---| ---| --- |
 |[0000.两数之和](https://github.com/youngyangyang04/leetcode/blob/master/problems/0000.两数之和.md) | 数组|简单|**暴力** **哈希**| 
-|[0015.三数之和](https://github.com/youngyangyang04/leetcode/blob/master/problems/0015.三数之和.md) | 数组|中等|**双指针** 哈希| 
+|[0015.三数之和](https://github.com/youngyangyang04/leetcode/blob/master/problems/0015.三数之和.md) | 数组 |中等|**双指针** **哈希**| 
+|[0018.四数之和](https://github.com/youngyangyang04/leetcode/blob/master/problems/0018.四数之和) | 数组 |中等|**双指针**| 
 |[0021.合并两个有序链表](https://github.com/youngyangyang04/leetcode/blob/master/problems/0021.合并两个有序链表.md)  |链表 |简单|**模拟** |
 |[0026.删除排序数组中的重复项](https://github.com/youngyangyang04/leetcode/blob/master/problems/0026.删除排序数组中的重复项.md)  |数组 |简单|**暴力** **快慢指针** |
 |[0027.移除元素](https://github.com/youngyangyang04/leetcode/blob/master/problems/0027.移除元素.md)  |数组 |简单| **暴力** **快慢指针**|
diff --git a/problems/0015.三数之和.md b/problems/0015.三数之和.md
index ecd40033..d050b390 100644
--- a/problems/0015.三数之和.md
+++ b/problems/0015.三数之和.md
@@ -5,9 +5,9 @@ https://leetcode-cn.com/problems/3sum/
 
 ### 哈希解法
 
-去重的过程不好处理，有很多小细节，如果在面试中很难想到位，需要在oj上不断尝试
+去重的过程不好处理，有很多小细节，如果在面试中很难想到位
 
-时间复杂度：O(n^2)
+时间复杂度：O(n^2)，但是运行时间很长，不好做剪枝操作
 
 ### 双指针
 
@@ -15,8 +15,54 @@ https://leetcode-cn.com/problems/3sum/
 
 时间复杂度：O(n^2)
 
-## 代码
+## 哈希法代码
 
+
+```
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        vector<vector<int>> result;
+        sort(nums.begin(), nums.end());
+        for (int i = 0; i < nums.size(); i++) {
+            // 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
+            if (nums[i] > 0) {
+                continue;
+            }
+            if (i > 0 && nums[i] == nums[i - 1]) { //三元组第一个元素去重
+                continue;
+            }
+            unordered_set<int> set;
+            for (int j = i + 1; j < nums.size(); j++) {
+                if (j > i + 2
+                        && nums[j] == nums[j-1]
+                        && nums[j-1] == nums[j-2]) { // 三元组第三个元素去重
+                    continue;
+                }
+                int c = 0 - (nums[i] + nums[j]);
+                if (set.find(c) != set.end()) {
+                    result.push_back({nums[i], nums[j], c});
+                    set.erase(c);// 三元组第二个元素去重
+                } else {
+                    set.insert(nums[j]);
+                }
+            }
+        }
+        return result;
+    }
+};
+```
+
+```
+Input
+[-2,0,0,2,2]
+Output
+[[-2,2,0],[-2,2,0]]
+Expected
+[[-2,0,2]]
+```
+
+## 双指针法代码
 ```
 class Solution {
 public:
diff --git a/problems/0018.四数之和.md b/problems/0018.四数之和.md
new file mode 100644
index 00000000..08da733d
--- /dev/null
+++ b/problems/0018.四数之和.md
@@ -0,0 +1,55 @@
+
+## 题目地址 
+https://leetcode-cn.com/problems/4sum/  
+
+## 思路 
+
+四数之和，和[三数之和](https://github.com/youngyangyang04/leetcode/blob/master/problems/0015.三数之和.md)是一个思路，都是使用双指针法，但是有一些细节需要注意，例如： 不要判断`nums[k] > target` 就返回了，三数之和 可以通过 `nums[i] > 0` 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值
+
+## C++代码
+```
+class Solution {
+public:
+    vector<vector<int>> fourSum(vector<int>& nums, int target) {
+        vector<vector<int>> result;
+        sort(nums.begin(), nums.end());
+        for (int k = 0; k < nums.size(); k++) {
+            // 这中剪枝是错误的，这道题目target 是任意值 
+            // if (nums[k] > target) {
+            //     return result;
+            // }
+            // 去重
+            if (k > 0 && nums[k] == nums[k - 1]) {
+                continue;
+            }
+            for (int i = k + 1; i < nums.size(); i++) {
+                // 正确去重方法
+                if (i > k + 1 && nums[i] == nums[i - 1]) {
+                    continue;
+                }
+                int left = i + 1;
+                int right = nums.size() - 1;
+                while (right > left) {
+                    if (nums[k] + nums[i] + nums[left] + nums[right] > target) {
+                        right--;
+                    } else if (nums[k] + nums[i] + nums[left] + nums[right] < target) {
+                        left++;
+                    } else {
+                        result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
+                        // 去重逻辑应该放在找到一个四元组之后
+                        while (right > left && nums[right] == nums[right - 1]) right--;
+                        while (right > left && nums[left] == nums[left + 1]) left++;
+
+                        // 找到答案时，双指针同时收缩
+                        right--;
+                        left++;
+                    }
+                }
+
+            }
+        }
+        return result;
+    }
+
+};
+```
diff --git a/problems/0454.四数相加II.md b/problems/0454.四数相加II.md
index 6949c6e3..df3ba954 100644
--- a/problems/0454.四数相加II.md
+++ b/problems/0454.四数相加II.md
@@ -17,21 +17,21 @@ https://leetcode-cn.com/problems/4sum-ii/
 class Solution {
 public:
     int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
-        unordered_map<int, int> umap;
-        for (int x : A) {
-            for (int y : B) {
-                if (umap.find(x + y) != umap.end()) {
-                    umap[x + y]++;
+        unordered_map<int, int> umap; //key:a+b的数值，value:a+b数值出现的次数
+        for (int a : A) {
+            for (int b : B) {
+                if (umap.find(a + b) != umap.end()) {
+                    umap[a + b]++;
                 } else {
-                    umap[x + y] = 1;
+                    umap[a + b] = 1;
                 }
             }
         }
         int count = 0;
-        for (int x : C) {
-            for (int y : D) {
-                if (umap.find(0 - (x + y)) != umap.end()) {
-                    count += umap[0 - (x + y)]; // 注意这里是加上umap[0 - (x + y)]的值
+        for (int c : C) {
+            for (int d : D) {
+                if (umap.find(0 - (c + d)) != umap.end()) {
+                    count += umap[0 - (c + d)]; 
                 }
             }
         }