由于Rust中的元组实现了PartialOrd和字典序比较，因此可以使用sort_by_key()方法：

my_vector.sort_unstable_by_key(|item| (item.row, item.column));

Playground。

您还可以为MyStruct实现PartialOrd或Ord< module std::CMP >

use core::cmp::Ordering;

# [derive(Debug, Eq, PartialEq, Ord)]

struct MyStruct {
    row: u8,
    column: u8,
}

impl PartialOrd for MyStruct {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        if self.row == other.row {
            return Some(self.column.cmp(&other.column));
        }
        Some(self.row.cmp(&other.row))
    }
}

fn main() {
    let mut my_vector = vec![
        MyStruct { row: 10, column: 3 },
        MyStruct { row: 10, column: 1 },
        MyStruct { row: 10, column: 2 },
    ];
    my_vector.sort();
    println!("{:?}", my_vector);
}

playground

通过整理前两个解决方案的信息，并在GitHub Copilot的帮助下，这里有一个sort by two keys排序方法的工作解决方案：
在可变向量的sort_by方法上使用compare参数：

my_vector.sort_by(| a, b | if a.row == b.row {
  a.column.partial_cmp(&b.column).unwrap()
} else {
  a.row.partial_cmp(&b.row).unwrap()
});

并使用：

println!("{:#?}", locations);

将输出：

let mut locations = vec![
  Location {
    row: 1,
    column: 1
  },
  Location {
    row: 1,
    column: 2
  },
  Location {
    row: 2,
    column: 1
  },
  Location {
    row: 2,
    column: 2
  }
];

你可以使用sort_by（）

my_vector.sort_by(|a, b| ...);

通过a和B，u可以设置条件，以便为排序link返回true

我认为使用match是一个更好的选择，因为它只比较每一对一次。使用sort_unstable_by可能会更好一些，因为unstable更快，而且可以使任何比较反向进行（降序）--只需为cmp()调用交换a和b。

struct MyStruct{
    row: u8,
    column: u8
}

fn sort(items: &mut [MyStruct]) {
    items.sort_unstable_by(|a, b| {
        match a.row.cmp(&b.row) {
            Ordering::Equal => { a.column.cmp(&b.column) }
            v => { v }
        }
    });
}