Rust中无Copy trait的Vec<Vec<T>>转置：求规避Clone与索引的方案

问题背景 #

需要将类型为Vec<Vec<T>>的矩阵A转置为同类型矩阵B，其中T不实现Copy trait。示例：

A = [ [t1,t2,t3], [t4,t5,t6] ]
B = [ [t1,t4], [t2,t5], [t3,t6] ]

已验证三种可行实现方案（假设A包含M个长度为N的子向量）：

方案一 #

let B: Vec<Vec<T>> = (0..N)
        .map(|i| A
            .iter()
            .map(|x| (*x.iter().skip(i).next().unwrap()).clone())
            .collect::<Vec<_>>()
        )
        .collect::<Vec<_>>();

方案二 #

let B: Vec<Vec<T>> = (0..N)
        .map(|i| A
            .iter()
            .map(|x| x[i].clone())
            .collect::<Vec<_>>()
        )
        .collect::<Vec<_>>();

方案三 #

let A = A.into_iter().flatten().collect::<Vec<T>>();
let B: Vec<Vec<T>> = (0..N)
        .map(|i| A
            .iter()
            .enumerate()
            .filter(|(v, _)| *v % N == i)
            .map(|(_, j)| j.clone())
            .collect::<Vec<_>>()
        )
        .collect::<Vec<_>>();

优化方案：减少/避免Clone与索引使用 #

方案四：所有权转移（零Clone，仅一次索引） #

若允许消耗原矩阵A（转置后不再使用A），可直接转移元素所有权，完全规避Clone：

fn transpose<T>(mut A: Vec<Vec<T>>) -> Vec<Vec<T>> {
    if A.is_empty() {
        return Vec::new();
    }
    let col_count = A[0].len();
    // 预先分配转置矩阵的内存
    let mut transposed = vec![Vec::with_capacity(A.len()); col_count];
    
    for row in A.iter_mut() {
        // 用drain获取行内元素所有权，逐个转移到对应列
        for (col_idx, item) in row.drain(..).enumerate() {
            transposed[col_idx].push(item);
        }
    }
    
    transposed
}

特点：仅在初始化时用一次索引获取列数，全程通过迭代器和所有权转移操作，无Clone开销，性能最优。

方案五：迭代器安全访问（减少显式索引） #

若必须保留原矩阵，可通过get方法替代直接索引，避免panic的同时减少显式索引使用：

fn transpose_clone<T: Clone>(matrix: &Vec<Vec<T>>) -> Vec<Vec<T>> {
    if matrix.is_empty() {
        return Vec::new();
    }
    let col_count = matrix[0].len();
    
    (0..col_count)
        .map(|col| {
            matrix.iter()
                .filter_map(|row| row.get(col))
                .cloned()
                .collect()
        })
        .collect()
}

特点：用get(col)替代row[col]，在矩阵行长度不一致时更安全；仅一次索引获取列数，其余用迭代器方法完成。

方案六：迭代器组合（零显式索引） #

若矩阵行长度固定，可通过预创建行迭代器的方式，完全避免显式索引：

fn transpose_no_index<T: Clone>(matrix: &Vec<Vec<T>>) -> Vec<Vec<T>> {
    if matrix.is_empty() {
        return Vec::new();
    }
    let col_count = matrix[0].len();
    // 为每一行创建克隆迭代器
    let mut row_iters: Vec<_> = matrix.iter().map(|row| row.iter().cloned()).collect();
    
    (0..col_count)
        .map(|_| {
            row_iters.iter_mut()
                .filter_map(|iter| iter.next())
                .collect()
        })
        .collect()
}

特点：全程无显式索引操作，通过迭代器逐个提取对应元素，代码更简洁。

总结 #

• 允许消耗原矩阵时，方案四是最优选择，零Clone开销且性能最高
• 需保留原矩阵时，方案五和方案六可有效减少显式索引使用，兼顾安全与简洁

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