如何按对象双参数排序链表？稀疏矩阵链表行优先排序输出需求

嘿，我来帮你搞定这两个问题！

核心思路就是自定义排序规则：先以第一个参数作为主要排序依据，当第一个参数相等时，再用第二个参数进行二次排序。具体实现会因编程语言略有差异，但逻辑是通用的，我给你举两个常见语言的例子：

Python 实现示例 #

假设你的链表节点存储着包含param1和param2的对象：

# 链表节点类
class ListNode:
    def __init__(self, obj):
        self.obj = obj
        self.next = None

# 自定义排序逻辑：先比param1，再比param2（升序）
def sort_linked_list_by_two_params(head):
    # 先把链表中的所有对象提取到列表中
    obj_list = []
    current = head
    while current:
        obj_list.append(current.obj)
        current = current.next
    
    # 用元组作为排序键，实现双参数排序
    obj_list.sort(key=lambda x: (x.param1, x.param2))
    
    # 重新构建有序链表
    new_head = ListNode(obj_list[0]) if obj_list else None
    current = new_head
    for obj in obj_list[1:]:
        current.next = ListNode(obj)
        current = current.next
    return new_head

Java 实现示例 #

可以让元素类实现Comparable接口，或者使用Comparator自定义规则：

// 元素类实现Comparable接口，定义排序逻辑
class TargetObject implements Comparable<TargetObject> {
    int param1;
    int param2;

    @Override
    public int compareTo(TargetObject other) {
        // 先比较param1，相等则比较param2
        if (this.param1 != other.param1) {
            return Integer.compare(this.param1, other.param1);
        }
        return Integer.compare(this.param2, other.param2);
    }
}

// 链表排序方法（将链表转成集合排序后重构）
public ListNode sortLinkedList(ListNode head) {
    List<TargetObject> objList = new ArrayList<>();
    ListNode current = head;
    while (current != null) {
        objList.add(current.obj);
        current = current.next;
    }
    Collections.sort(objList);
    // 重构有序链表（省略链表构建的常规代码）
    return newHead;
}

如果不想转成集合，也可以给链表排序算法（比如归并排序、冒泡排序）替换比较逻辑，但转集合排序的实现成本更低，适合大多数场景。

你的需求是行号升序优先，行号相同则列号升序，然后输出row col data。结合你提到的元素结构，我给你一套完整的实现方案：

步骤1：定义元素类与链表节点 #

# 稀疏矩阵元素类
class MatrixElement:
    def __init__(self, data, row, col):
        self.data = data
        self.row = row
        self.col = col

# 链表节点类
class ListNode:
    def __init__(self, elem):
        self.elem = elem
        self.next = None

步骤2：排序并输出 #

def print_sparse_matrix_in_order(head):
    # 收集所有矩阵元素
    elements = []
    current = head
    while current:
        elements.append(current.elem)
        current = current.next
    
    # 按行优先、列次之的规则排序
    elements.sort(key=lambda x: (x.row, x.col))
    
    # 按要求格式输出
    for elem in elements:
        print(f"{elem.row} {elem.col} {elem.data}")

# 测试示例
elem1 = MatrixElement(5, 2, 0)
elem2 = MatrixElement(8, 0, 2)
elem3 = MatrixElement(1, 0, 1)

# 构建无序链表
head = ListNode(elem1)
head.next = ListNode(elem2)
head.next.next = ListNode(elem3)

# 调用输出函数
print_sparse_matrix_in_order(head)

运行后会输出：

0 1 1
0 2 8
2 0 5

如果你的场景是频繁插入元素但需要多次输出，也可以在插入时就维护有序链表：每次插入新元素时，遍历找到它应该在的位置（按行、列顺序）插入，这样后续直接遍历链表就能输出有序结果，省去每次排序的开销。

内容的提问来源于stack exchange，提问作者Adam Tamargo