Row-wise vs column-wise traversal of matrix

Two common ways of traversing a matrix are row-major-order and column-major-order. 
Row Major Order: When matrix is accessed row by row. 
Column Major Order: When matrix is accessed column by column.
Examples: 

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

Difference: If we see according to time complexity, both lead to O(n²), but when it comes to cache level one of the orders access will be faster as compare to other one. It depends on the language we are using. Like in C, store matrix in row major form so while accessing the i+1^th element after i^th, most probably it will lead to a hit, which will further reduce the time of program. 

The following codes are showing the time difference in row major and column major access. 

C++

// 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

// 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

# Python3 program showing time difference
# in row major and column major access

# taking MAX 10000 so that time difference
# can be shown
from time import perf_counter
MAX = 1000

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 = perf_counter()
    rowMajor()
    t = perf_counter() - t
    print("Row major access time :{:.2f} s".format(t))

    # Time taken by column major order
    t = perf_counter()
    colMajor()
    t = perf_counter() - t
    print("Column major access time :{:.2f} s".format(t))

# This code is contributed by mohit kumar 29

C#

// 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

Javascript

// JavaScript program showing time difference
// in row major and column major access

// taking MAX 10000 so that time difference can be shown
let MAX = 1000

function rowMajor() {
    let i, j;

    // accessing element row wise
    for (i = 0; i < MAX; i++) {
        for (j = 0; j < MAX; j++) {
            arr[i][j]++;
        }
    }
}

function colMajor() {
    let i, j;
    // accessing element column wise
    for (i = 0; i < MAX; i++) {
        for (j = 0; j < MAX; j++) {
            arr[j][i]++;
        }
    }
}

// Driver code

var arr = new Array(MAX);
for (let i = 0; i < MAX; i++)
    arr[i] = new Array(MAX);

// Time taken by row major order
let start, end;
start = Date.now();
rowMajor();
end = Date.now();
console.log(`Row major access time: ${end - start} ms`);

// Time taken by column major order
start = Date.now();
colMajor();
end = Date.now();
console.log(`Col major access time: ${end - start} ms`);

// This code is contributed by ajaymakavana.

Output:

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

Time Complexity: O(MAX*MAX)
Auxiliary Space: O(MAX*MAX)