Recorrido de la array por filas y por columnas

Dos formas comunes de recorrer una array son el orden principal de filas y el orden principal de columnas. 
Orden principal de fila: cuando se accede a la array fila por fila. 
Orden principal de columna: cuando se accede a la array columna por columna.
Ejemplos: 
 

Input : mat[][] = {{1, 2, 3}, 
                  {4, 5, 6}, 
                  {7, 8, 9}}
Output : Row-wise: 1 2 3 4 5 6 7 8 9
         Col-wise : 1 4 7 2 5 8 3 6 9

Diferencia: si vemos de acuerdo con la complejidad del tiempo, ambos conducen a O (n ² ) , pero cuando se trata del nivel de caché, el acceso a una de las órdenes será más rápido en comparación con la otra. Depende del lenguaje que estemos usando. Al igual que en C , almacene la array en forma de fila principal, de modo que al acceder al elemento i+1 ^th después de i ^th , lo más probable es que conduzca a un acierto, lo que reducirá aún más el tiempo del programa. 
Los siguientes códigos muestran la diferencia de tiempo en el acceso principal de fila y columna principal. 
 

// C program showing time difference
// in row major and column major access
#include <stdio.h>
#include <time.h>
 
// taking MAX 10000 so that time difference
// can be shown
#define MAX 10000
 
int arr[MAX][MAX] = {0};
 
void rowMajor() {
 
  int i, j;
 
  // accessing element row wise
  for (i = 0; i < MAX; i++) {
    for (j = 0; j < MAX; j++) {
      arr[i][j]++;
    }
  }
}
 
void colMajor() {
 
  int i, j;
 
  // accessing element column wise
  for (i = 0; i < MAX; i++) {
    for (j = 0; j < MAX; j++) {
      arr[j][i]++;
    }
  }
}
 
// driver code
int main() {
  int i, j;
 
  // Time taken by row major order
  clock_t t = clock();
  rowMajor();
  t = clock() - t;
  printf("Row major access time :%f s\n",
                t / (float)CLOCKS_PER_SEC);
 
  // Time taken by column major order
  t = clock();
  colMajor();
  t = clock() - t;
  printf("Column major access time :%f s\n",
               t / (float)CLOCKS_PER_SEC);
  return 0;
}

// Java program showing time difference
// in row major and column major access
import java.time.Duration;
import java.time.Instant;
import java.util.*;
 
class GFG
{
 
// taking MAX 10000 so that time difference
// can be shown
static int MAX= 10000;
 
static int [][]arr = new int[MAX][MAX];
 
static void rowMajor()
{
 
    int i, j;
     
    // accessing element row wise
    for (i = 0; i < MAX; i++)
    {
        for (j = 0; j < MAX; j++)
        {
        arr[i][j]++;
        }
    }
}
 
static void colMajor()
{
 
    int i, j;
     
    // accessing element column wise
    for (i = 0; i < MAX; i++)
    {
        for (j = 0; j < MAX; j++)
        {
        arr[j][i]++;
        }
    }
}
 
// Driver code
public static void main(String[] args)
{
 
    // Time taken by row major order
    Instant start = Instant.now();
    rowMajor();
    Instant end = Instant.now();
        System.out.println("Row major access time : "+
                    Duration.between(start, end));
     
    // Time taken by column major order
    start = Instant.now();
    colMajor();
    end = Instant.now();
    System.out.printf("Column major access time : "+
                    Duration.between(start, end));
}
}
 
// This code is contributed by 29AjayKumar

# Python3 program showing time difference
# in row major and column major access
 
# taking MAX 10000 so that time difference
# can be shown
MAX = 1000
from time import clock
 
arr = [[ 0 for i in range(MAX)] for i in range(MAX)]
 
def rowMajor():
    global arr
     
    # accessing element row wise
    for i in range(MAX):
        for j in range(MAX):
            arr[i][j] += 1
 
def colMajor():
    global arr
 
    # accessing element column wise
    for i in range(MAX):
        for j in range(MAX):
            arr[j][i] += 1
 
# Driver code
if __name__ == '__main__':
 
    # Time taken by row major order
    t = clock()
    rowMajor();
    t = clock() - t
    print("Row major access time :{:.2f} s".format(t))
 
    # Time taken by column major order
    t = clock()
    colMajor()
    t = clock() - t
    print("Column major access time :{:.2f} s".format(t))
 
# This code is contributed by mohit kumar 29

// C# program showing time difference
// in row major and column major access
using System;
using  static System.DateTime;
public class GFG
{
   
  // taking MAX 10000 so that time difference
  // can be shown
  public static int MAX = 1000;
  public static int[,] arr = new int[GFG.MAX,GFG.MAX];
  public static void rowMajor()
  {
    int i;
    int j;
    // accessing element row wise
    for (
      i = 0; i < GFG.MAX; i++)
    {
      for (
        j = 0; j < GFG.MAX; j++)
      {
        GFG.arr[i,j]++;
      }
    }
  }
  public static void colMajor()
  {
    int i;
    int j;
    // accessing element column wise
    for (
      i = 0; i < GFG.MAX; i++)
    {
      for (
        j = 0; j < GFG.MAX; j++)
      {
        GFG.arr[j,i]++;
      }
    }
  }
  // Driver code
  public static void Main(String[] args)
  {
    // Time taken by row major order
    var start = DateTime.UtcNow;
    GFG.rowMajor();
    var end = DateTime.UtcNow;
    TimeSpan spanR = end.Subtract( start );
    Console.WriteLine("Row major access time : " + spanR.TotalMinutes + " min");
 
    // Time taken by column major order
    start = DateTime.UtcNow;
    GFG.colMajor();
    end = DateTime.UtcNow;
    TimeSpan spanC = end.Subtract( start );
    Console.WriteLine("Column major access time : " + spanC.TotalMinutes + " min");
  }
}
 
// This code is contributed by yoursthek2002

Row major access time :0.492000 s
Column major access time :1.621000 s