# 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(n2), 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+1th element after ith, 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 ` `#include `   `// 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)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next