c++之分而治之是否总能获得更好的表现

我目前正在测试一些分而治之的算法与它们的正常实现。我对此很陌生，我不确定在使用分而治之时是否应该始终获得更好的性能。例如，我已经实现了一种算法来按常规转置矩阵并使用分而治之，但我仍然使用第一个版本获得更好的性能。有可能还是我遗漏了一些重要的东西？

下面是分而治之的代码

void trasponer_DyV(Matriz &matriz) 
{ 
    if (matriz.size() >= 2) 
    { 
        trasponer_DyV(matriz, 0, matriz.size(), 0, matriz.size()); 
    } 
} 
 
void trasponer_DyV(Matriz &matriz, int fil_inicio, int fil_fin, int col_inicio, int col_fin) 
{ 
    int tam = fil_fin - fil_inicio; 
 
    if (tam == 1) 
        return; 
 
    trasponer_DyV(matriz,fil_inicio, fil_inicio + tam / 2,col_inicio, col_inicio + tam / 2); 
    trasponer_DyV(matriz, fil_inicio, fil_inicio + tam / 2, col_inicio + tam / 2, col_inicio + tam); 
    trasponer_DyV(matriz, fil_inicio + tam / 2, fil_inicio + tam, col_inicio, col_inicio + tam / 2); 
    trasponer_DyV(matriz, fil_inicio + tam / 2, fil_inicio + tam, col_inicio + tam / 2, col_inicio + tam); 
 
    for (int i = 0; i < tam / 2; i++) 
    { 
        for (int j = 0; j < tam / 2; j++) 
            swap(matriz[fil_inicio + i][col_inicio + tam / 2 + j], matriz[fil_inicio + tam / 2 + i][col_inicio + j]); 
    } 
} 

这是蛮力的:

Matriz trasponer_fuerzabruta(const Matriz &matriz) 
{ 
    Matriz ret; 
    ret.resize(matriz.size()); 
    for (int i = 0; i < matriz.size(); ++i) 
    { 
        ret[i].resize(matriz.size()); 
    } 
 
    // Todo lo que hacemos es sustituir filas por columnas. 
    for (int fila = 0; fila < matriz.size(); ++fila) 
    { 
        for (int columna = 0; columna < matriz.size(); ++columna) 
        { 
            ret[columna][fila] = matriz[fila][columna]; 
        } 
    } 
 
    return ret; 
} 

提前致谢!

请您参考如下方法:

第一个版本做了更多工作 - 它就地转置片段，然后将它们交换到正确的位置。

第二个版本一次转置一个元素，但已经转置到最终位置。

此外，在顺序过程中，分治法仅在工作集不适合 L3 缓存(8MB 或更多)时才有用，这相当于大小为 >1000*1000 的矩阵。

虽然(在 CPU 级别)并行化它也没有好处，因为矩阵转置是完全 DRAM 绑定(bind)的操作。