队列的Java - LL实现为每个LL节点复制队列

Question

我正在尝试用Java语言编写一个RadixSort的例子，虽然我理解算法是如何工作的，但我在实现一个链式队列列表时遇到了一些问题。

我认为我的问题是当我更新第n个位置的链表时，用一个新的队列作为它的值。我相信我对每个节点更新都使用相同的队列，这导致我为链表中的每个节点获取相同的值。

因此，当从int[] theArray = {4,3,5,9,7,2,4,1,6,5};数组开始时

我最终得到了一个包含10个节点的链表，每个节点包含一个队列：{4,3,5,9,7,2,4,1,6,5}

我认为通过使用new关键字，它将创建一个新的实例，但它似乎在每次迭代中都会继承旧值。

有人能向我解释或指出正确的方向来理解为什么会发生这种情况吗？

编辑：(忘记附加代码)

package radixsort;
import java.util.*;
/**
 * @author dlanz
 */
public class RadixSort {

    public static void main(String[] args) {

        int[] theArray = {4,3,5,9,7,2,4,1,6,5};

        RadixSort theSort = new RadixSort();

        System.out.println(Arrays.toString(theArray)); //Outputs the original array
        theSort.sort(theArray);
        System.out.println(Arrays.toString(theArray)); //Outputs the original array (no modifictions)
    }



    public void sort(int[] theArray) {
        int significant;
        int curVal;    
        int modulo = 10;
        int ofInterest = 1;

        LinkedList<Queue> lists = new LinkedList<>();
        Queue<Integer> queue = new LinkedList<>();

        int max = theArray[0];
        for(int i = 0; i < theArray.length; i++) {
            if ( theArray[i] > max) {
                  max = theArray[i];
            }
        }
        significant = String.valueOf(max).length();
        Queue<Integer> thisQueue;
        for(int j = 1; j <= significant; j++){

            lists.clear();
            for(int i = 0; i < 10; i++){
                lists.add(i, queue);
            }
            System.out.println(lists); //Outputs a list of 10 elements each with a value of null
            for(int value : theArray){
                  curVal = value % modulo;
                  curVal = curVal / ofInterest;
                  System.out.println(curVal); //Correctly outputs the expected result
                  System.out.println(lists.get(curVal)); //With each iteration this outputs 10 elements each with a queue of all values.

                  thisQueue = new LinkedList<>();
                  thisQueue = lists.get(curVal);
                  thisQueue.add(value);

                  lists.set(curVal, thisQueue);// This seems to insert the generated queue into every linked lists node.
            }
            int k = 0;
            for(int i = 0; i < 10; i++){
                Queue<Integer> curQueue = lists.get(i);
                if(!curQueue.isEmpty()){
                    theArray[k] = curQueue.remove();
                    k++;
                }
            }
            ofInterest = ofInterest * 10;
            modulo = modulo * 10;
        }
    }
}

编辑2：

我一直在尝试它，看起来好像thisQueue，lists和queue是共享的。当我在thisQueue上执行某些操作时，例如thisQueue.add(1)，'1‘的值被全盘添加。如果我在lists上对lists.add(1)执行相同的操作，则lists中的每个节点都将填充值1。

我记得我读过一些关于通过引用传递对象值的文章(但不是对象本身)，这和我所经历的有什么关系吗？

编辑3：

我还注意到，如果在.add()行中使用文字而不是变量，例如

thisQueue.add(value);

值不会像编辑2中提到的那样重复。我尝试将使用的变量转换为int，即使它们被声明为Int，但仍然得到相同的结果。

Answer 1

奇怪的是，我很欣赏没有人回答这个问题。我自己找出了答案，同时创建了一组示例代码，并提出了一个不太具体的问题。但在很长一段时间内，我都不会忘记这一点。

在我循环遍历并在链表中创建节点0-9的那段代码中发生了什么

for(int i = 0; i < 10; i++){
    lists.add(i, queue);
}

我正在添加一个对同一队列的引用。因此，不管是否使用其他Queues/.clear()，我实际上是在该行上拉出对该原始队列的引用

thisQueue = lists.get(curVal);

虽然我在此过程中做了一些更改，但真正需要做的就是将循环更改为

for(int i = 0; i < 10; i++){
    queue = new LinkedList<>();
    lists.add(i, queue);
}

和改变

Queue<Integer> queue = new LinkedList<>();

只是为了

Queue<Integer> queue

我曾经想过显式地创建10个单独的队列，然后在代码中使用一个开关来决定应该使用哪个队列。这似乎不是很灵活，而且会非常单调乏味。同时，我意识到为每次迭代创建一个新的队列是非常昂贵的。我将创建与数组中一样多的对象，在本例中是10个，但这可能是100,1000,1000000。通过使用匿名对象(如果我错了，请纠正我)，我能够根据需要创建尽可能多的对象(链表中的每个元素一个)。