LinkedList添加Java

我创建了一个节点类，它的行、列和数据都是int。我正在尝试制作一个稀疏矩阵。我想在添加它们时对它们进行排序，以提高效率。我首先需要按行排序，如果行相同，则按列排序。我尝试过几种不同的方法，但没有一种有效。我使用的是Java linkedList类以及迭代器。例如，如果添加元素（1,1,3）、（2,2,4）和（1,3,5），当我打印出来时，它应该是（1,1,3）、（1,3,5）和（2,2,4）

这是我目前的代码：

public void addElement(int row, int col, int data) {
    if(matrix.size() == 0){
        Node new_node = new Node(row, col, data); 
        matrix.add(new_node);
        System.out.print("test \n");
    }
    Iterator<Node> iterator = matrix.iterator();
    Node temp = new Node();
    temp = iterator.next(); 
    int i = -1; // counter
    int size = matrix.size();
    int node_row  = temp.getRow();
    int node_col = temp.getColumn();
    System.out.print("iterator test \n");
    while(iterator.hasNext() || size == 1){
        System.out.print("test 5");
        while(row>node_row){
            i++;
            node_row++;
        }
        while(row == node_row && col>node_col){
            i++;
            node_col++;
        }
        break; 
    }
    if(i<=0){
        Node new_node = new Node(row, col, data); 
        matrix.add(0, new_node);
    }
    else{
    Node new_node = new Node(row, col, data); 
    matrix.add(i, new_node);
    }
}

public void addElement（int行、int列、int数据）{
if（matrix.size（）==0）{
Node new_Node=新节点（行、列、数据）；
添加（新的_节点）；
系统输出打印（“测试”）；
}
迭代器迭代器=矩阵。迭代器（）；
节点温度=新节点（）；
temp=iterator.next（）；
int i=-1；//计数器
int size=matrix.size（）；
int node_row=temp.getRow（）；
int node_col=temp.getColumn（）；
System.out.print（“迭代器测试”）；
while（iterator.hasNext（）| | size==1）{
系统输出打印（“测试5”）；
while（行>节点\行）{
i++；
node_row++；
}
while（row==node\u row&&col>node\u col）{
i++；
node_col++；
}
打破
}
如果（i我的解决方案实现了一个自定义插入方法，使用要插入的元素、要插入的列表（任何列表实现）和要使用的比较器。您可能应该使用二进制搜索方法优化插入逻辑，但至少很容易理解。这假设传入列表中的任何元素都已排序

public class SortMatrixCells
{
    static class Cell<T>
    {
        private int column;
        private int row;
        private T value;

        Cell(int row, int column, T value)
        {
            this.row = row;
            this.column = column;
            this.value = value;
        }    

        public String toString()
        {
            return String.format("[%s,%s,%s]", row, column, value);
        }
    }

    private final static Comparator<Cell> cellComparator = new Comparator<Cell>() {

        @Override
        public int compare(Cell c1, Cell c2)
        {
            int result = 0;

            // Compare row values.
            if (c1.row < c2.row)
            {
                result = -1;
            }
            else if (c1.row > c2.row)
            {
                result = 1;
            }

            // If rows are equal, compare column values.
            else
            {
                if (c1.column < c2.column)
                {
                    result = -1;
                }
                else if (c1.column > c2.column)
                {
                    result = 1;
                }
            }

            return result;
        }
    };

    public static void main(String[] args)
    {
        List<Cell<Integer>> matrixCells = new ArrayList<>();

        insert(new Cell<Integer>(2, 2, 4), matrixCells, cellComparator);
        System.out.println("List so far: " + matrixCells);

        insert(new Cell<Integer>(1, 3, 5), matrixCells, cellComparator);
        System.out.println("List so far: " + matrixCells);

        insert(new Cell<Integer>(1, 1, 3), matrixCells, cellComparator);
        System.out.println("List so far: " + matrixCells);
    }

    private static <T> void insert(T elementToInsert, List<T> list, Comparator comparator)
    {
        boolean inserted = false;

        ListIterator<T> itrElements = list.listIterator();

        for (; itrElements.hasNext();)
        {
            int comparison = comparator.compare(elementToInsert, itrElements.next());

            switch (comparison)
            {
                case -1:
                case 0:
                    itrElements.previous();
                    itrElements.add(elementToInsert);
                    inserted = true;

                    break;
            }

            if (inserted)
            {
                break;
            }
        }

        if (!inserted)
        {
            itrElements.add(elementToInsert);
        }
    }
}

公共类SortMatrixCells
{
静态类单元
{
私有int列；
私人int row；
私人T值；
单元格（整行、整列、T值）
{
this.row=行；
this.column=列；
这个值=值；
}    
公共字符串toString（）
{
返回String.format（“[%s，%s，%s]”，行，列，值）；
}
}
私有最终静态比较器cellComparator=新比较器（）{
@凌驾
公共整数比较（单元格c1、单元格c2）
{
int结果=0；
//比较行值。
如果（c1.世界其他地区c2.行）
{
结果=1；
}
//如果行相等，则比较列值。
其他的
{
如果（c1.列c2.列）
{
结果=1；
}
}
返回结果；
}
};
公共静态void main（字符串[]args）
{
List matrixCells=new ArrayList（）；
插入（新单元（2，2，4），矩阵单元，单元比较器）；
System.out.println（“到目前为止的列表：+matrixCells”）；
插入（新单元（1、3、5）、矩阵单元、单元比较器）；
System.out.println（“到目前为止的列表：+matrixCells”）；
插入（新单元格（1,1,3）、矩阵单元格、单元格比较器）；
System.out.println（“到目前为止的列表：+matrixCells”）；
}
私有静态void插入（T elementToInsert、列表、比较器）
{
布尔插入=假；
ListIterator itrElements=list.ListIterator（）；
对于（；itrElements.hasNext（）；）
{
int comparison=comparator.compare（elementToInsert，itrElements.next（））；
开关（比较）
{
案例1：
案例0：
itrElements.previous（）；
添加（elementToInsert）；
插入=真；
打破
}
如果（插入）
{
打破
}
}
如果（！插入）
{
添加（elementToInsert）；
}
}
}

还有一件事：除非你有一个压倒一切的理由在你将它们添加到列表时对它们进行排序，否则我真的建议你简单地创建一个列表，将所有元素添加到尾部。然后只需调用
Collections.sort（list，cellcomarator）
它实现了合并排序。即使使用二进制搜索方法，最终也应该比排序更有效。
你能更具体地回答你的问题吗？那它不起作用了吗？另外，你能不能也添加你的主方法，这样我们就可以有相同的输入，并能够复制你的问题？