将列表范围转换为子列表，并将它们存储在linkedlist类型的列表中

Question

我已经有一个包含值的列表类型Integer，我想从索引0开始顺序测试，如果一个元素范围的总和满足特定值，那么将该范围复制到列表中并将其存储在链表列表中。然后再次按顺序测试，但现在从前一个范围的下一个索引开始，因此，如果前一个范围是从索引0到索引9，那么从索引10开始，并重复该过程，直到最后一个索引。

List<Integer> arrayB = new LinkedList<Integer>(); //this is the array with values in it
List<LinkedList> p = new LinkedList<LinkedList>();// this is the array of arrays  
List<Integer> arrayA = new LinkedList<Integer>();// this is the range or the sub list of arrayB
public void function(int n)// suppose that n = 6 and arrayB have these value {1,2,3,1,1,1,1,2}
{
    int count = 0;
    for (int w : arrayB)
    {
        count = w + count;
        arrayA.add(w);
        if(count == n)
        {
            count = 0;
            p.add((LinkedList) arrayA);
            arrayA.clear();
        }
    }
}

然而，当我在arrayA中调用clear方法时，这段代码失败了，所以不管使用的数据结构如何，是否有任何替代代码使用这种逻辑?

Answer 1

我对问题的理解如下:存在一个数组，您希望从中提取一定范围的值，假设它们满足某些标准。在这种情况下，标准是值域求值为某个和。完成此操作后，您可能希望重复该过程，直到耗尽原始数据结构中的所有值。我将假设您的原始数据结构是一个整数数组，而您得到的数据结构是一个整数数组链表。

一种方法是保留一个全局计数器来跟踪原始数组的当前索引，例如:

int[] originalArray = {//list of numbers separated by commas};
LinkedList<Integer[]> resultingList = new LinkedList<>();
int currentIndex = 0;
public static void function(int totalSum) {
    int currentSum = 0;
    int initialIndex = currentIndex;
    while((currentSum != totalSum) && (currentIndex < (originalArray.length - 1))) {
        if(currentSum + initialArray[currentIndex] <= totalSum) {
            currentSum += initialArray[currentIndex];
            currentIndex++;
        } 
        else {
            break;
        }
    }
    if(currentSum = totalSum) {
        int[] arrayToAdd = new int[currentIndex - initialIndex - 1];
        for(int i = 0; i < currentIndex - initialIndex; i++) {
            arrayToAdd[i] = originalArray[initialIndex + i];
        }
        resultingList.add(arrayToAdd);
    }
}

Answer 2

每次向p中添加子列表时都使用相同的列表引用arrayA, p中的每个列表元素都指向相同的arrayA。所以当你调用arraya。clear();清除p中的所有列表元素。

要纠正这个错误，需要在向arrayA添加子列表时创建一个新的列表对象:

public static void function(int n)// suppose that n = 6 and arrayB have these value {1,2,3,1,1,1,1,2}
{
    int count = 0;
    LinkedList<Integer> subList = new LinkedList<>();
    for (int w : arrayB) {
        count = w + count;
        subList.add(w);
        if (count == n) {
            count = 0;
            p.add((LinkedList) subList); // p is adding a new list reference every time
            subList = new LinkedList<>(); // create a new list object, subList points to a new list object
        }
    }
}

Answer 3

问题是，当您将链表添加到最终存储p中时，您假设列表的元素已放在那里。只有一个指针被引用，所以当你在下一行清除它时，所有的元素都消失了。

p.add((LinkedList) arrayA);
arrayA.clear();

一个技巧是将arrayA的作用域移到函数内部。这是因为它是临时的，并且只是一个子列表，所以它不应该在实例级别。可以通过执行 来重用它

arrayA = new LinkedList<Integer>();

，当你这样做的时候，你并没有丢失旧的列表，因为p保留了对它的引用。

另一个技巧是用有意义的名字来命名你的列表。

originalIntList, groupedIntList, singleGroupIntList可以帮助读者弄清楚他们可以做什么，而不仅仅是说明Java对象的明显方面的注释。