[剑指Offer] 38_字符串的排列

题目

输入一个字符串，打印出该字符串中字符的所有排列。

例：

输入：‘abc’
输出：‘abc’, ‘acb’, ‘bac’, ‘cab’, ‘cba’

---

思路

1. 长度为n的字符串的排列若是集合S，其中一种排列的字符串为$<s_1,s_2,...,s_n>$，再插入$s_{n+1}$，则有对于一个字符串有n+1个插入位置。因此，解题思路就是每次递归加入一个字符，直到字符串全部被加入递归结束。每次递归中都有n+1种插入分支。
   1. 时间复杂度：O(n!)，T(n) = T(n-1) + T(n-1)*O(n)
   2. 空间复杂度：O(n^2)，O(n)的递归深度，每次递归传入O(n)的字符串。
2. 书上的解法不使用插入，而是用了交换，实际上是一样的。但是由于是对同一个列表操作，而不是传入新的列表分片，减小了空间复杂度。
   1. 时间复杂度：O(n!)
   2. 空间复杂度：O(n)

---

代码

思路1：时间复杂度：O(n!)，空间复杂度：O(n^2)

def string_permutation(string):
    """
    :param string:string
    :return: permutation list
    """
    def recursion_core(pre_s, string):
        """        
        :param pre_s: n-1 sol
        :param string: str waiting to add
        :return: n sol
        """
        if not string:
            ans.append(pre_s)
            return
        for s in range(len(string)):
            recursion_core(pre_s + string[s], string[:s]+string[s+1:])
    ans = []
    recursion_core('', string)
    return ans

思路2：时间复杂度：O(n!)，空间复杂度：O(n)

def string_permutation_2(string):
    """
    :param string: string
    :return: permutation list
    """
    def recursion_core(string, start):
        """
        :param string: total string
        :param start: all permutation of string[start:]
        :return:
        """
        if start == len(string):
            comb.append(''.join(string))
        else:
            for i in range(start,len(string)):
                string[i], string[start] = string[start], string[i]
                recursion_core(string, start+1)
                string[i], string[start] = string[start], string[i]
    comb = []
    recursion_core(list(string), 0)
    return comb

---

思考

相同的题目

LeetCode 46. 全排列

题目

给定一个没有重复数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

代码

class Solution:
    def permute(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        def recursion_core(element, start):
            if start == len(element):
                comb.append(element[:])
            else:
                for i in range(start, len(element)):
                    element[i], element[start] = element[start], element[i]
                    recursion_core(element, start + 1)
                    element[i], element[start] = element[start], element[i]
        comb = []
        recursion_core(nums, 0)
        return comb
    
    def permute_2(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        
        def recursion_core(pre_s, string):
            if not string:
                ans.append(pre_s)
                return
            for s in range(len(string)):
                recursion_core(pre_s + [string[s]], string[:s] + string[s + 1:])
    
        ans = []
        recursion_core([], nums)
        return ans