切片附加的行为异常

问题描述

有人可以向我解释为什么temp的值决定在最后一条输出行更改，即使temp只是列表数组的副本吗？

func subsets(nums []int) [][]int {
    
    if len(nums) == 0 {
        return [][]int{[]int{}}
    }
    
    list := [][]int{[]int{nums[0]}}
    
    for _,n := range nums[1:]{
        list = append(list,[]int{n})
        temp := list[:len(list)-1]
        fmt.Println(temp)
        for _,arr := range temp {
            arr = append(arr,n)
            list = append(list,arr)
        }
       
        fmt.Println(temp)
        fmt.Println("  ")
    }
    
    list = append(list,[]int{})
    return list
    
}

output:
[[1]]
[[1]]
  
[[1] [2] [1 2]]
[[1] [2] [1 2]]
  
[[1] [2] [1 2] [3] [1 3] [2 3] [1 2 3]]
[[1] [2] [1 2] [3] [1 3] [2 3] [1 2 3]]
  
[[1] [2] [1 2] [3] [1 3] [2 3] [1 2 3] [4] [1 4] [2 4] [1 2 4] [3 4] [1 3 4] [2 3 4] [1 2 3 4]]
[[1] [2] [1 2] [3] [1 3] [2 3] [1 2 3] [4] [1 4] [2 4] [1 2 4] [3 4] [1 3 4] [2 3 4] [1 2 3 5]]

解决方法

实际上，您是在复制切片，而不是数组。 切片是数组段的描述符。它由一个指向数组的指针，段的长度及其容量（段的最大长度）组成。 这意味着，您只是在创建slice标题的副本。底层数组仍被共享。 https://blog.golang.org/slices-intro

,

这是Go中数组和切片的一个非常普遍的问题（与Python和JavaScript中的不同）。您会习惯的，本answer中已经对此进行了解释。

---

当然，here还会介绍解决方案，我想您会知道它是如何工作的。

---

这将使用backtracking（更容易实现）传递给Go：

func subsets(nums []int) [][]int {
    subs := make([][]int,0)
    backtrack(nums,nil,&subs)
    return subs
}

func backtrack(nums []int,index int,sub []int,subs *[][]int) {
    if index == len(nums) {
        *subs = append(*subs,append([]int{},sub...))
        return
    }

    backtrack(nums,index+1,sub,subs)
    backtrack(nums,append(sub,nums[index]),subs)
}

与Java类似，

public final class Solution {
    public static final List<List<Integer>> subsets(
        final int[] nums
    ) {
        List<List<Integer>> subs = new ArrayList<>();
        Arrays.sort(nums);
        backtrack(subs,new ArrayList<>(),nums,0);
        return subs;
    }

    private static void backtrack(
        final List<List<Integer>> subs,final List<Integer> sub,final int[] nums,final int start
    ) {
        subs.add(new ArrayList<>(sub));

        for (int index = start; index < nums.length; index++) {
            sub.add(nums[index]);
            backtrack(subs,index + 1);
            sub.remove(sub.size() - 1);
        }
    }
}

反复进行（例如，使用C ++）：

// The following block might trivially improve the exec time;
// Can be removed;
static const auto __optimize__ = []() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(NULL);
    std::cout.tie(NULL);
    return 0;
}();


// Most of headers are already included;
// Can be removed;
#include <cstdint>
#include <vector>


using ValueType = std::uint_fast16_t;

static const struct Solution {
    static const std::vector<std::vector<int>> subsets(
            const std::vector<int>& nums
    ) {
        std::vector<std::vector<int>> subs = {{}};
        ValueType subs_len;

        for (const auto& num : nums) {
            subs_len = std::size(subs);

            for (ValueType len = 0; len < subs_len; ++len) {
                subs.emplace_back(subs[len]);
                subs.back().emplace_back(num);
            }
        }

        return subs;
    }
};

Python还有一个combinations工具，可以使其变得简单：

class Solution:
    def subsets(self,nums):
        return (tuple(j) for i in range(len(nums) + 1) for j in itertools.combinations(nums,i))

---

参考文献

• 有关其他详细信息，请参见Discussion Board，在这里您可以找到许多具有各种languages且已被广泛接受的解决方案，包括低复杂度算法和渐近runtime / {{ 3}}分析^memory，1 。