Análisis de rendimiento del orden principal de fila y columna de arrays iterativas en C

En informática, el orden principal de filas y el orden principal de columnas son métodos para almacenar arrays multidimensionales en almacenamiento lineal, como la memoria de acceso aleatorio.
Las dos formas mencionadas difieren entre sí con respecto al orden en que los elementos se almacenan contiguamente en la memoria. Los elementos en orden de fila principal se organizan consecutivamente a lo largo de la fila y los que están en orden de columna principal se organizan consecutivamente a lo largo de la columna. Si bien los términos aluden a las filas y columnas de una array bidimensional, es decir, una array, los órdenes pueden generalizarse a arrays de cualquier dimensión al señalar que los términos fila principal y columna principal son equivalentes a órdenes lexicográficos y lexicográficos. respectivamente.
En C (y muchos otros lenguajes como C++, Java, etc.), las arrays 2-D se almacenan en orden de fila principal (aunque Pascal y Fortran siguen el orden principal de columna)

Este programa NO ilustra que el almacenamiento de arreglos en orden principal de fila en C es más eficiente que el orden principal de columna.

Solo muestra que en el lenguaje C, las arrays 2-D se almacenan en orden principal de fila y, por lo tanto, iterar sus elementos en un orden principal de fila es más eficiente.

En lenguajes como Pascal y Fortran, la iteración por orden de columna principal será más eficiente porque las arrays 2-D se almacenan en orden de columna principal allí.

El motivo de esto se explica correctamente aquí https://cs.stackexchange.com/questions/71985/row-major-vs-column-major-order-2d-arrays-access-in-programming-languages. 
 

#include <stdio.h>
#include <time.h>
int m[999][999];
//Taking both dimensions same so that while running the loops,
//number of operations (comparisons, iterations, initializations)
//are exactly the same. Refer this for more
// https://www.geeksforgeeks.org/a-nested-loop-puzzle/
 
void main()
 
{
    int i, j;
    clock_t start, stop;
    double d = 0.0;
 
    start = clock();
    for (i = 0; i < 999; i++)
        for (j = 0; j < 999; j++)
            m[i][j] = m[i][j] + (m[i][j] * m[i][j]);
 
    stop = clock();
    d = (double)(stop - start) / CLOCKS_PER_SEC;
    printf("The run-time of row major order is %lf\n", d);
 
    start = clock();
    for (j = 0; j < 999; j++)
        for (i = 0; i < 999; i++)
            m[i][j] = m[i][j] + (m[i][j] * m[i][j]);
 
    stop = clock();
    d = (double)(stop - start) / CLOCKS_PER_SEC;
    printf("The run-time of column major order is %lf", d);
}

The run-time of row major order is 0.067300
The run-time of column major order is 0.136622

Complejidad de tiempo : O (999 * 999), ya que estamos usando bucles anidados para atravesar 999 * 999 veces.

Espacio auxiliar : O (999 * 999), ya que estamos usando espacio adicional para la array.