Update 46.permutations.md

Author: azl397985856

problems/46.permutations.md

@@ -52,9 +52,9 @@ https://leetcode-cn.com/problems/permutations/
 
 以 [1,1,2] 为例，我们的逻辑是：
 
-- 先从 [1,1,2] 选取一个数
+- 先从 [1,1,2] 选取一个数。
 - 然后继续从 [1,1,2] 选取一个数，并且这个数不能是已经选取过的数。
-- 重复这个过程直到选取的数字达到了 3，
+- 重复这个过程直到选取的数字达到了 3。
 
 ## 关键点解析
 
@@ -90,32 +90,6 @@ var permute = function (nums) {
 
 Python3 Code:
 
-```Python
-class Solution:
-    def permute(self, nums: List[int]) -> List[List[int]]:
-        """itertools库内置了这个函数"""
-        return itertools.permutations(nums)
-
-    def permute2(self, nums: List[int]) -> List[List[int]]:
-        """自己写回溯法"""
-        res = []
-        def _backtrace(nums, pre_list):
-            if len(nums) <= 0:
-                res.append(pre_list)
-            else:
-                for i in nums:
-                    # 注意copy一份新的调用，否则无法正常循环
-                    p_list = pre_list.copy()
-                    p_list.append(i)
-                    left_nums = nums.copy()
-                    left_nums.remove(i)
-                    _backtrace(left_nums, p_list)
-        _backtrace(nums, [])
-        return res
-```
-
-Python Code:
-
 ```Python
 class Solution:
     def permute(self, nums: List[int]) -> List[List[int]]:
@@ -126,7 +100,7 @@ class Solution:
     def permute2(self, nums: List[int]) -> List[List[int]]:
         """自己写回溯法"""
         res = []
-        def _backtrace(nums, pre_list):
+        def backtrack(nums, pre_list):
             if len(nums) <= 0:
                 res.append(pre_list)
             else:
@@ -136,23 +110,23 @@ class Solution:
                     p_list.append(i)
                     left_nums = nums.copy()
                     left_nums.remove(i)
-                    _backtrace(left_nums, p_list)
-        _backtrace(nums, [])
+                    backtrack(left_nums, p_list)
+        backtrack(nums, [])
         return res
 
     def permute3(self, nums: List[int]) -> List[List[int]]:
         """回溯的另一种写法"""
         res = []
         length = len(nums)
-        def _backtrack(start=0):
+        def backtrack(start=0):
             if start == length:
                 # nums[:] 返回 nums 的一个副本，指向新的引用，这样后续的操作不会影响已经已知解
                 res.append(nums[:])
             for i in range(start, length):
                 nums[start], nums[i] = nums[i], nums[start]
-                _backtrack(start+1)
+                backtrack(start+1)
                 nums[start], nums[i] = nums[i], nums[start]
-        _backtrack()
+        backtrack()
         return res
 ```