Python 子集一组不同的整数nums返回所有可能的子集

比如说,， 如果nums=[1,2,3]，则解决方案为：

[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

我的代码如下：

class Solution(object):

"""
:type nums: List[int]
:rtype: List[List[int]]
"""
def subsets(self, nums):
    if not nums or len(nums) == 0:
        return 


    nums.sort()

    subset = []
    results = [[]]
    self.subsetHelper(nums, 0, subset, results)

    return results

def subsetHelper(self, nums, startIndex, subset, results):
    # subset is 1D list store elements that create results
    # results is 2D list that store results created

    results.append(subset)

    for i in range(startIndex, len(nums)):
        subset.append(nums[i])
        # recursion:
        self.subsetHelper(nums, i+1, subset, results)
        # backtracking:
        subset.pop()

[1,2,3]的答案假设为：

[[],[3],[2],[2,3],[1],[1,3],[1,2],[1,2,3]]

我的答案是：

[[],[],[],[],[],[],[],[],[]]

有人能告诉我哪里出了问题，以及如何修改它以获得

[[3]、[1]、[2]、[1,2,3]、[1,3]、[2,3]、[1,2]、[1,2]。]

---

谢谢。

您可以使用它生成给定列表的所有子列表：

list = [1,2,3]

def subset(i):
    finallist = []
    for first in range(0,len(i)+1):
        for last in range(first+1,len(i)+1):
            templist = []
            for index in range(first,last):
                templist.append(i[index])
            finallist.append(templist)
    return finallist


print(subset(list))

但是，这不包括[1,3]，因为这不是真正的子列表。要对列表进行所有可能的组合，请参见：

---

您的问题是列表是可变的

简要解释可突变性以及它是如何引起问题的，请考虑下面的代码-

x = something # mutable type
x = y
print x
# some statement that operates on y
print x # might print something different

现在在我们的例子中，

结果

中的一个元素可以被视为类似于上例中的

x

，而

子集

则被视为

y

的模拟。因此，在

子集中进行更改会对结果进行更改

解决方案-

好的，因为我们的问题是由于列表是可变的，所以将
子集
转换为元组（不可变）将有助于解决问题。这只需将
result.append（subset）
更改为
result.append（tuple（subset））
即可完成

最后，如果您确实希望
结果
具有
列表
而不是元组，则可以使用
results.append（list（tuple（subset））
。这将创建一个lit from元组，该元组与
子集没有任何关系
，因此不会因可变性而发生危险

Extra-您可能希望将
result
初始化为
result=[]
而不是
result=[[]
。与后面的情况一样，它会在列表列表中添加一个额外的空列表。：）
您可以为此使用itertools