Estructura de datos copia profunda y copia superficial

Encontré un informe de error causado por una copia superficial al hacer el problema de combinación del algoritmo de retroceso al cepillar la pregunta

Primero mira el problema

En primer lugar, el siguiente código tendrá un problema de copia superficial. Este problema hará que los elementos del conjunto de resultados cambien con el cambio del objeto al que apunta la ruta, porque el resultado agregado es el objeto al que apunta la ruta, por lo que Quiero que el resultado no cambie con la ruta. Debemos dejar que el resultado haga una copia profunda de la ruta.

El resultado de este código es [[], [], [], [], [], []]

El resultado debe ser [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]

import java.util.*;
public class backstacking
{
    public backstacking() {
    }

    public static void main(String[] args)
    {
        backstacking x2=new backstacking();
        List<List<Integer>>x= x2.combine(4,2);

        System.out.println(x);
    }

    List<List<Integer>> result = new ArrayList<List<Integer>>();
    List<Integer> path= new ArrayList<Integer>();
    List<Integer> path2;
    public List<List<Integer>> combine(int n, int k)
    {
        backstracking(n,k,1);
        return result;

    }
    public void  backstracking(int n,int k,int startindex)
    {
        if(path.size()==k)
        {
 //           path2=new ArrayList<Integer>();
 //           for (int i: path)
 //           {
 //              path2.add(i);

 //           }

//            result.add(path2);
               result.add(path);//这段代码就会出现浅拷贝引起的问题
            return ;
        }
        for(int i=startindex;i<=n;i++)
        {
            path.add(i);
            backstracking(n,k,i+1);
            path.remove(path.size()-1);

        }
    }

}

El código después de una copia profunda es:

import java.util.*;
public class backstacking
{
    public backstacking() {
    }

    public static void main(String[] args)
    {
        backstacking x2=new backstacking();
        List<List<Integer>>x= x2.combine(4,2);

        System.out.println(x);
    }

    List<List<Integer>> result = new ArrayList<List<Integer>>();
    List<Integer> path= new ArrayList<Integer>();
    List<Integer> path2;
    public List<List<Integer>> combine(int n, int k)
    {
        backstracking(n,k,1);
        return result;

    }
    public void  backstracking(int n,int k,int startindex)
    {
        if(path.size()==k)
        {
            //深拷贝代码开始
            path2=new ArrayList<Integer>();
            for (int i: path)
            {
                path2.add(i);

            }

            result.add(path2);
            //深拷贝结束
            return ;
        }
        for(int i=startindex;i<=n;i++)
        {
            path.add(i);
            backstracking(n,k,i+1);
            path.remove(path.size()-1);

        }
    }

}