剑指Offer：字符串的排列

对于数组来说： 

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        # res用来存放结果
        if not nums: return []
        res = []
        used = [0] * len(nums)
        def backtracking(nums, used, path):
            # 终止条件
            if len(path) == len(nums):
                res.append(path.copy())
                return
            for i in range(len(nums)):
                if not used[i]:
                    if i>0 and nums[i] == nums[i-1] and not used[i-1]:
                        continue
                    used[i] = 1
                    path.append(nums[i])
                    backtracking(nums, used, path)
                    path.pop()
                    used[i] = 0
        # 记得给nums排序
        backtracking(sorted(nums),used,[])
        return res

对于字符串来说：

class Solution(object):
    def permutation(self, s):
        """
        :type s: str
        :rtype: List[str]
        """
        n = len(s)
        if n == 0:
            return []
        
        res = []
        used = [0] * n
        s_list = list(s)
        s_list = sorted(s_list)

        def back_tracking(s_list, used, path):
            if len(s_list) == len(path):
                string = ''.join(path)
                res.append(string)
                return

            for i in range(n):
                if not used[i]:
                    if i > 0 and s_list[i] == s_list[i-1] and used[i-1] == 0:
                        continue
                    path.append(s_list[i])
                    used[i] = 1
                    back_tracking(s_list, used, path)
                    path.pop()
                    used[i] = 0

        back_tracking(s_list, used, [])

        return res