());
return result;
}
- Arrays.sort(nums);
subsetsHelper(nums, 0);
return result;
}
diff --git a/problems/0110.平衡二叉树.md b/problems/0110.平衡二叉树.md
index dfc27344..1cd54849 100644
--- a/problems/0110.平衡二叉树.md
+++ b/problems/0110.平衡二叉树.md
@@ -142,7 +142,7 @@ int getDepth(TreeNode* node)
2. 明确终止条件
-递归的过程中依然是遇到空节点了为终止,返回0,表示当前节点为根节点的书高度为0
+递归的过程中依然是遇到空节点了为终止,返回0,表示当前节点为根节点的树高度为0
代码如下:
@@ -534,7 +534,34 @@ func abs(a int)int{
return a
}
```
-
+JavaScript:
+```javascript
+var isBalanced = function(root) {
+ //还是用递归三部曲 + 后序遍历 左右中 当前左子树右子树高度相差大于1就返回-1
+ // 1. 确定递归函数参数以及返回值
+ const getDepth=function(node){
+ // 2. 确定递归函数终止条件
+ if(node===null){
+ return 0;
+ }
+ // 3. 确定单层递归逻辑
+ let leftDepth=getDepth(node.left);//左子树高度
+ if(leftDepth===-1){
+ return -1;
+ }
+ let rightDepth=getDepth(node.right);//右子树高度
+ if(rightDepth===-1){
+ return -1;
+ }
+ if(Math.abs(leftDepth-rightDepth)>1){
+ return -1;
+ }else{
+ return 1+Math.max(leftDepth,rightDepth);
+ }
+ }
+ return getDepth(root)===-1?false:true;
+};
+```
-----------------------
diff --git a/problems/0131.分割回文串.md b/problems/0131.分割回文串.md
index 9b2401de..c722af37 100644
--- a/problems/0131.分割回文串.md
+++ b/problems/0131.分割回文串.md
@@ -292,7 +292,24 @@ class Solution {
```
Python:
-
+```python3
+class Solution:
+ def partition(self, s: str) -> List[List[str]]:
+ res = []
+ path = [] #放已经回文的子串
+ def backtrack(s,startIndex):
+ if startIndex >= len(s): #如果起始位置已经大于s的大小,说明已经找到了一组分割方案了
+ return res.append(path[:])
+ for i in range(startIndex,len(s)):
+ p = s[startIndex:i+1] #获取[startIndex,i+1]在s中的子串
+ if p == p[::-1]: path.append(p) #是回文子串
+ else: continue #不是回文,跳过
+ backtrack(s,i+1) #寻找i+1为起始位置的子串
+ path.pop() #回溯过程,弹出本次已经填在path的子串
+ backtrack(s,0)
+ return res
+
+```
Go:
diff --git a/problems/0150.逆波兰表达式求值.md b/problems/0150.逆波兰表达式求值.md
index 618a6830..e38bc1a3 100644
--- a/problems/0150.逆波兰表达式求值.md
+++ b/problems/0150.逆波兰表达式求值.md
@@ -197,6 +197,32 @@ func evalRPN(tokens []string) int {
}
```
+javaScript:
+
+```js
+
+/**
+ * @param {string[]} tokens
+ * @return {number}
+ */
+var evalRPN = function(tokens) {
+ const s = new Map([
+ ["+", (a, b) => a * 1 + b * 1],
+ ["-", (a, b) => b - a],
+ ["*", (a, b) => b * a],
+ ["/", (a, b) => (b / a) | 0]
+ ]);
+ const stack = [];
+ for (const i of tokens) {
+ if(!s.has(i)) {
+ stack.push(i);
+ continue;
+ }
+ stack.push(s.get(i)(stack.pop(),stack.pop()))
+ }
+ return stack.pop();
+};
+```
-----------------------
diff --git a/problems/0202.快乐数.md b/problems/0202.快乐数.md
index 06a6914c..c07405ec 100644
--- a/problems/0202.快乐数.md
+++ b/problems/0202.快乐数.md
@@ -22,13 +22,13 @@ https://leetcode-cn.com/problems/happy-number/
**示例:**
-输入:19
-输出:true
-解释:
-1^2 + 9^2 = 82
-8^2 + 2^2 = 68
-6^2 + 8^2 = 100
-1^2 + 0^2 + 0^2 = 1
+输入:19
+输出:true
+解释:
+1^2 + 9^2 = 82
+8^2 + 2^2 = 68
+6^2 + 8^2 = 100
+1^2 + 0^2 + 0^2 = 1
# 思路
@@ -36,7 +36,7 @@ https://leetcode-cn.com/problems/happy-number/
题目中说了会 **无限循环**,那么也就是说**求和的过程中,sum会重复出现,这对解题很重要!**
-正如:[关于哈希表,你该了解这些!](https://mp.weixin.qq.com/s/g8N6WmoQmsCUw3_BaWxHZA)中所说,**当我们遇到了要快速判断一个元素是否出现集合里的时候,就要考虑哈希法了。**
+正如:[关于哈希表,你该了解这些!](https://mp.weixin.qq.com/s/RSUANESA_tkhKhYe3ZR8Jg)中所说,**当我们遇到了要快速判断一个元素是否出现集合里的时候,就要考虑哈希法了。**
所以这道题目使用哈希法,来判断这个sum是否重复出现,如果重复了就是return false, 否则一直找到sum为1为止。
@@ -80,7 +80,7 @@ public:
-## 其他语言版本
+# 其他语言版本
Java:
diff --git a/problems/0203.移除链表元素.md b/problems/0203.移除链表元素.md
index 7735f6c4..dce5d265 100644
--- a/problems/0203.移除链表元素.md
+++ b/problems/0203.移除链表元素.md
@@ -15,7 +15,18 @@ https://leetcode-cn.com/problems/remove-linked-list-elements/
题意:删除链表中等于给定值 val 的所有节点。
-
+示例 1:
+输入:head = [1,2,6,3,4,5,6], val = 6
+输出:[1,2,3,4,5]
+
+示例 2:
+输入:head = [], val = 1
+输出:[]
+
+示例 3:
+输入:head = [7,7,7,7], val = 7
+输出:[]
+
# 思路
@@ -201,6 +212,29 @@ Python:
Go:
+```go
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ * Val int
+ * Next *ListNode
+ * }
+ */
+func removeElements(head *ListNode, val int) *ListNode {
+ dummyHead := &ListNode{}
+ dummyHead.Next = head
+ cur := dummyHead
+ for cur != nil && cur.Next != nil {
+ if cur.Next.Val == val {
+ cur.Next = cur.Next.Next
+ } else {
+ cur = cur.Next
+ }
+ }
+ return dummyHead.Next
+}
+```
+
javaScript:
```js
diff --git a/problems/0209.长度最小的子数组.md b/problems/0209.长度最小的子数组.md
index bd25083e..90280451 100644
--- a/problems/0209.长度最小的子数组.md
+++ b/problems/0209.长度最小的子数组.md
@@ -116,26 +116,6 @@ public:
不要以为for里放一个while就以为是$O(n^2)$啊, 主要是看每一个元素被操作的次数,每个元素在滑动窗后进来操作一次,出去操作一次,每个元素都是被被操作两次,所以时间复杂度是2 * n 也就是$O(n)$。
-## 其他语言补充
-
-python:
-
-```python
-class Solution:
- def minSubArrayLen(self, s: int, nums: List[int]) -> int:
- # 定义一个无限大的数
- res = float("inf")
- Sum = 0
- index = 0
- for i in range(len(nums)):
- Sum += nums[i]
- while Sum >= s:
- res = min(res, i-index+1)
- Sum -= nums[index]
- index += 1
- return 0 if res==float("inf") else res
-```
-
## 相关题目推荐
* 904.水果成篮
@@ -170,6 +150,22 @@ class Solution {
Python:
+```python
+class Solution:
+ def minSubArrayLen(self, s: int, nums: List[int]) -> int:
+ # 定义一个无限大的数
+ res = float("inf")
+ Sum = 0
+ index = 0
+ for i in range(len(nums)):
+ Sum += nums[i]
+ while Sum >= s:
+ res = min(res, i-index+1)
+ Sum -= nums[index]
+ index += 1
+ return 0 if res==float("inf") else res
+```
+
Go:
```go
diff --git a/problems/0222.完全二叉树的节点个数.md b/problems/0222.完全二叉树的节点个数.md
index 5a3cfcbc..2e2fed99 100644
--- a/problems/0222.完全二叉树的节点个数.md
+++ b/problems/0222.完全二叉树的节点个数.md
@@ -243,6 +243,74 @@ Python:
Go:
+JavaScript:
+
+递归版本
+```javascript
+var countNodes = function(root) {
+ //递归法计算二叉树节点数
+ // 1. 确定递归函数参数
+ const getNodeSum=function(node){
+ //2. 确定终止条件
+ if(node===null){
+ return 0;
+ }
+ //3. 确定单层递归逻辑
+ let leftNum=getNodeSum(node.left);
+ let rightNum=getNodeSum(node.right);
+ return leftNum+rightNum+1;
+ }
+ return getNodeSum(root);
+};
+```
+
+迭代(层序遍历)版本
+```javascript
+var countNodes = function(root) {
+ //层序遍历
+ let queue=[];
+ if(root===null){
+ return 0;
+ }
+ queue.push(root);
+ let nodeNums=0;
+ while(queue.length){
+ let length=queue.length;
+ while(length--){
+ let node=queue.shift();
+ nodeNums++;
+ node.left&&queue.push(node.left);
+ node.right&&queue.push(node.right);
+ }
+ }
+ return nodeNums;
+};
+```
+
+利用完全二叉树性质
+```javascript
+var countNodes = function(root) {
+ //利用完全二叉树的特点
+ if(root===null){
+ return 0;
+ }
+ let left=root.left;
+ let right=root.right;
+ let leftHeight=0,rightHeight=0;
+ while(left){
+ left=left.left;
+ leftHeight++;
+ }
+ while(right){
+ right=right.right;
+ rightHeight++;
+ }
+ if(leftHeight==rightHeight){
+ return Math.pow(2,leftHeight+1)-1;
+ }
+ return countNodes(root.left)+countNodes(root.right)+1;
+};
+```
diff --git a/problems/0225.用队列实现栈.md b/problems/0225.用队列实现栈.md
index e045229f..055c2e3d 100644
--- a/problems/0225.用队列实现栈.md
+++ b/problems/0225.用队列实现栈.md
@@ -357,8 +357,115 @@ class MyStack:
Go:
+javaScript:
+使用数组(push, shift)模拟队列
+```js
+
+// 使用两个队列实现
+/**
+ * Initialize your data structure here.
+ */
+var MyStack = function() {
+ this.queue1 = [];
+ this.queue2 = [];
+};
+
+/**
+ * Push element x onto stack.
+ * @param {number} x
+ * @return {void}
+ */
+MyStack.prototype.push = function(x) {
+ this.queue1.push(x);
+};
+
+/**
+ * Removes the element on top of the stack and returns that element.
+ * @return {number}
+ */
+MyStack.prototype.pop = function() {
+ // 减少两个队列交换的次数, 只有当queue1为空时,交换两个队列
+ if(!this.queue1.length) {
+ [this.queue1, this.queue2] = [this.queue2, this.queue1];
+ }
+ while(this.queue1.length > 1) {
+ this.queue2.push(this.queue1.shift());
+ }
+ return this.queue1.shift();
+};
+
+/**
+ * Get the top element.
+ * @return {number}
+ */
+MyStack.prototype.top = function() {
+ const x = this.pop();
+ this.queue1.push(x);
+ return x;
+};
+
+/**
+ * Returns whether the stack is empty.
+ * @return {boolean}
+ */
+MyStack.prototype.empty = function() {
+ return !this.queue1.length && !this.queue2.length;
+};
+
+```
+
+```js
+
+// 使用一个队列实现
+/**
+ * Initialize your data structure here.
+ */
+var MyStack = function() {
+ this.queue = [];
+};
+
+/**
+ * Push element x onto stack.
+ * @param {number} x
+ * @return {void}
+ */
+MyStack.prototype.push = function(x) {
+ this.queue.push(x);
+};
+
+/**
+ * Removes the element on top of the stack and returns that element.
+ * @return {number}
+ */
+MyStack.prototype.pop = function() {
+ let size = this.queue.length;
+ while(size-- > 1) {
+ this.queue.push(this.queue.shift());
+ }
+ return this.queue.shift();
+};
+
+/**
+ * Get the top element.
+ * @return {number}
+ */
+MyStack.prototype.top = function() {
+ const x = this.pop();
+ this.queue.push(x);
+ return x;
+};
+
+/**
+ * Returns whether the stack is empty.
+ * @return {boolean}
+ */
+MyStack.prototype.empty = function() {
+ return !this.queue.length;
+};
+
+```
-----------------------
* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
diff --git a/problems/0232.用栈实现队列.md b/problems/0232.用栈实现队列.md
index 7c91a0dd..10314a08 100644
--- a/problems/0232.用栈实现队列.md
+++ b/problems/0232.用栈实现队列.md
@@ -353,6 +353,61 @@ func (this *MyQueue) Empty() bool {
*/
```
+ javaScript:
+
+ ```js
+ // 使用两个数组的栈方法(push, pop) 实现队列
+ /**
+ * Initialize your data structure here.
+ */
+var MyQueue = function() {
+ this.stack1 = [];
+ this.stack2 = [];
+};
+
+/**
+ * Push element x to the back of queue.
+ * @param {number} x
+ * @return {void}
+ */
+MyQueue.prototype.push = function(x) {
+ this.stack1.push(x);
+};
+
+/**
+ * Removes the element from in front of queue and returns that element.
+ * @return {number}
+ */
+MyQueue.prototype.pop = function() {
+ const size = this.stack2.length;
+ if(size) {
+ return this.stack2.pop();
+ }
+ while(this.stack1.length) {
+ this.stack2.push(this.stack1.pop());
+ }
+ return this.stack2.pop();
+};
+
+/**
+ * Get the front element.
+ * @return {number}
+ */
+MyQueue.prototype.peek = function() {
+ const x = this.pop();
+ this.stack2.push(x);
+ return x;
+};
+
+/**
+ * Returns whether the queue is empty.
+ * @return {boolean}
+ */
+MyQueue.prototype.empty = function() {
+ return !this.stack1.length && !this.stack2.length
+};
+ ```
+
diff --git a/problems/0257.二叉树的所有路径.md b/problems/0257.二叉树的所有路径.md
index 964bd7fd..fe7a2604 100644
--- a/problems/0257.二叉树的所有路径.md
+++ b/problems/0257.二叉树的所有路径.md
@@ -351,6 +351,30 @@ class Solution:
```
Go:
+JavaScript:
+1.递归版本
+```javascript
+var binaryTreePaths = function(root) {
+ //递归遍历+递归三部曲
+ let res=[];
+ //1. 确定递归函数 函数参数
+ const getPath=function(node,curPath){
+ //2. 确定终止条件,到叶子节点就终止
+ if(node.left===null&&node.right===null){
+ curPath+=node.val;
+ res.push(curPath);
+ return ;
+ }
+ //3. 确定单层递归逻辑
+ curPath+=node.val+'->';
+ node.left&&getPath(node.left,curPath);
+ node.right&&getPath(node.right,curPath);
+ }
+ getPath(root,'');
+ return res;
+};
+```
+
diff --git a/problems/0343.整数拆分.md b/problems/0343.整数拆分.md
index a6bd7211..c9423a1a 100644
--- a/problems/0343.整数拆分.md
+++ b/problems/0343.整数拆分.md
@@ -194,7 +194,23 @@ public:
Java:
-
+```Java
+class Solution {
+ public int integerBreak(int n) {
+ //dp[i]为正整数i拆分结果的最大乘积
+ int[] dp = new int[n+1];
+ dp[2] = 1;
+ for (int i = 3; i <= n; ++i) {
+ for (int j = 1; j < i - 1; ++j) {
+ //j*(i-j)代表把i拆分为j和i-j两个数相乘
+ //j*dp[i-j]代表把i拆分成j和继续把(i-j)这个数拆分,取(i-j)拆分结果中的最大乘积与j相乘
+ dp[i] = Math.max(dp[i], Math.max(j * (i - j), j * dp[i - j]));
+ }
+ }
+ return dp[n];
+ }
+}
+```
Python:
diff --git a/problems/0349.两个数组的交集.md b/problems/0349.两个数组的交集.md
index 46e15482..fe019a0a 100644
--- a/problems/0349.两个数组的交集.md
+++ b/problems/0349.两个数组的交集.md
@@ -118,6 +118,17 @@ class Solution {
```
Python:
+```python3
+class Solution:
+ def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
+ result_set = set()
+
+ set1 = set(nums1)
+ for num in nums2:
+ if num in set1:
+ result_set.add(num) # set1里出现的nums2元素 存放到结果
+ return result_set
+```
Go:
diff --git a/problems/0494.目标和.md b/problems/0494.目标和.md
index 84f99b1d..a9ddc768 100644
--- a/problems/0494.目标和.md
+++ b/problems/0494.目标和.md
@@ -19,15 +19,15 @@
示例:
-输入:nums: [1, 1, 1, 1, 1], S: 3
-输出:5
-解释:
+输入:nums: [1, 1, 1, 1, 1], S: 3
+输出:5
--1+1+1+1+1 = 3
-+1-1+1+1+1 = 3
-+1+1-1+1+1 = 3
-+1+1+1-1+1 = 3
-+1+1+1+1-1 = 3
+解释:
+-1+1+1+1+1 = 3
++1-1+1+1+1 = 3
++1+1-1+1+1 = 3
++1+1+1-1+1 = 3
++1+1+1+1-1 = 3
一共有5种方法让最终目标和为3。
diff --git a/problems/0669.修剪二叉搜索树.md b/problems/0669.修剪二叉搜索树.md
index 0b49bea2..06d99b9d 100644
--- a/problems/0669.修剪二叉搜索树.md
+++ b/problems/0669.修剪二叉搜索树.md
@@ -265,7 +265,9 @@ class Solution {
```
Python:
+
```python3
+
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
diff --git a/problems/0707.设计链表.md b/problems/0707.设计链表.md
index 2d76fffc..2fa1af29 100644
--- a/problems/0707.设计链表.md
+++ b/problems/0707.设计链表.md
@@ -158,6 +158,14 @@ private:
Java:
```Java
+class ListNode {
+int val;
+ListNode next;
+ListNode(){}
+ListNode(int val) {
+this.val=val;
+}
+}
class MyLinkedList {
//size存储链表元素的个数
int size;
diff --git a/problems/0746.使用最小花费爬楼梯.md b/problems/0746.使用最小花费爬楼梯.md
index 5ddcae0f..1e8e8038 100644
--- a/problems/0746.使用最小花费爬楼梯.md
+++ b/problems/0746.使用最小花费爬楼梯.md
@@ -225,7 +225,16 @@ class Solution {
```
Python:
-
+```python
+class Solution:
+ def minCostClimbingStairs(self, cost: List[int]) -> int:
+ dp = [0] * (len(cost))
+ dp[0] = cost[0]
+ dp[1] = cost[1]
+ for i in range(2, len(cost)):
+ dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]
+ return min(dp[len(cost) - 1], dp[len(cost) - 2])
+```
Go:
```Go
diff --git a/problems/0977.有序数组的平方.md b/problems/0977.有序数组的平方.md
new file mode 100644
index 00000000..167a258c
--- /dev/null
+++ b/problems/0977.有序数组的平方.md
@@ -0,0 +1,112 @@
+
+
+
+
+
+
+欢迎大家参与本项目,贡献其他语言版本的代码,拥抱开源,让更多学习算法的小伙伴们收益!
+
+> 双指针风骚起来,也是无敌
+
+# 977.有序数组的平方
+
+https://leetcode-cn.com/problems/squares-of-a-sorted-array/
+
+给你一个按 非递减顺序 排序的整数数组 nums,返回 每个数字的平方 组成的新数组,要求也按 非递减顺序 排序。
+
+示例 1:
+输入:nums = [-4,-1,0,3,10]
+输出:[0,1,9,16,100]
+解释:平方后,数组变为 [16,1,0,9,100],排序后,数组变为 [0,1,9,16,100]
+
+示例 2:
+输入:nums = [-7,-3,2,3,11]
+输出:[4,9,9,49,121]
+
+# 思路
+
+## 暴力排序
+
+最直观的相反,莫过于:每个数平方之后,排个序,美滋滋,代码如下:
+
+```C++
+class Solution {
+public:
+ vector sortedSquares(vector& A) {
+ for (int i = 0; i < A.size(); i++) {
+ A[i] *= A[i];
+ }
+ sort(A.begin(), A.end()); // 快速排序
+ return A;
+ }
+};
+```
+
+这个时间复杂度是 O(n + nlogn), 可以说是O(nlogn)的时间复杂度,但为了和下面双指针法算法时间复杂度有鲜明对比,我记为 O(n + nlogn)。
+
+## 双指针法
+
+数组其实是有序的, 只不过负数平方之后可能成为最大数了。
+
+那么数组平方的最大值就在数组的两端,不是最左边就是最右边,不可能是中间。
+
+此时可以考虑双指针法了,i指向起始位置,j指向终止位置。
+
+定义一个新数组result,和A数组一样的大小,让k指向result数组终止位置。
+
+如果`A[i] * A[i] < A[j] * A[j]` 那么`result[k--] = A[j] * A[j];` 。
+
+如果`A[i] * A[i] >= A[j] * A[j]` 那么`result[k--] = A[i] * A[i];` 。
+
+如动画所示:
+
+
+
+不难写出如下代码:
+
+```C++
+class Solution {
+public:
+ vector sortedSquares(vector& A) {
+ int k = A.size() - 1;
+ vector result(A.size(), 0);
+ for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j,因为最后要处理两个元素
+ if (A[i] * A[i] < A[j] * A[j]) {
+ result[k--] = A[j] * A[j];
+ j--;
+ }
+ else {
+ result[k--] = A[i] * A[i];
+ i++;
+ }
+ }
+ return result;
+ }
+};
+```
+
+此时的时间复杂度为O(n),相对于暴力排序的解法O(n + nlogn)还是提升不少的。
+
+
+**这里还是说一下,大家不必太在意leetcode上执行用时,打败多少多少用户,这个就是一个玩具,非常不准确。**
+
+做题的时候自己能分析出来时间复杂度就可以了,至于leetcode上执行用时,大概看一下就行,只要达到最优的时间复杂度就可以了,
+
+一样的代码多提交几次可能就击败百分之百了.....
+
+## 其他语言版本
+
+
+Java:
+
+Python:
+
+
+Go:
+
+
+-----------------------
+* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
+* B站视频:[代码随想录](https://space.bilibili.com/525438321)
+* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
+
diff --git a/problems/1047.删除字符串中的所有相邻重复项.md b/problems/1047.删除字符串中的所有相邻重复项.md
index 8b761be7..9ca08c96 100644
--- a/problems/1047.删除字符串中的所有相邻重复项.md
+++ b/problems/1047.删除字符串中的所有相邻重复项.md
@@ -186,6 +186,24 @@ class Solution:
Go:
+javaScript:
+
+```js
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var removeDuplicates = function(s) {
+ const stack = [];
+ for(const x of s) {
+ let c = null;
+ if(stack.length && x === (c = stack.pop())) continue;
+ c && stack.push(c);
+ stack.push(x);
+ }
+ return stack.join("");
+};
+```
diff --git a/problems/算法模板.md b/problems/算法模板.md
index 3b9eee8c..888ae773 100644
--- a/problems/算法模板.md
+++ b/problems/算法模板.md
@@ -82,13 +82,13 @@ void traversal(TreeNode* cur, vector& vec) {
traversal(cur->right, vec); // 右
}
```
-前序遍历(中左右)
+后序遍历(左右中)
```
void traversal(TreeNode* cur, vector& vec) {
if (cur == NULL) return;
- vec.push_back(cur->val); // 中 ,同时也是处理节点逻辑的地方
traversal(cur->left, vec); // 左
traversal(cur->right, vec); // 右
+ vec.push_back(cur->val); // 中 ,同时也是处理节点逻辑的地方
}
```
diff --git a/problems/背包总结篇.md b/problems/背包总结篇.md
index c04dfbec..0dd407ac 100644
--- a/problems/背包总结篇.md
+++ b/problems/背包总结篇.md
@@ -95,18 +95,6 @@
-## 其他语言版本
-
-
-Java:
-
-
-Python:
-
-
-Go:
-
-
-----------------------