Related Articles
Emulating a 2-d array using 1-d array
• Difficulty Level : Easy
• Last Updated : 17 Apr, 2018

How to convert a 2-d array of size (m x n) into 1-d array and how to store the element at position [i, j] of 2-d array in 1-d array? Clearly, the size of 1-d array is the number of elements in 2-d array i.e. (m x n). If the elements in the 2-d array are stored in row-major order. Then, the element at index [i, j] in 2-d array will be stored in 1-d array at index k as:

k = j + (i * total_no_of_columns_in_matrix)

If the elements in the 2-d array are stored in column-major order, the value of index k will be

k = i + (j * total_no_of_rows_in_matrix)

For more details about Row-major and Column-major order, refer to: https://en.wikipedia.org/wiki/Row-major_order

Examples :

```Given 2-d array:

// array is formed in row-major order
__________________________
|                          |
|1(0,0)    2(0,1)    3(0,2)|
|                          |
|4(1,0)    5(1,1)    6(1,2)|
|__________________________|

// The elements in parenthesis represents the
// index of the particular element in 2-d array.

Index of element at (0,1) in 1-d array will be:
k(0,1) = 1 + 0 * 3 = 1

Index of element at (1,1) in 1-d array will be:
k(1,1) = 1 + 1 * 3 = 4
```

## C++

 `// C++ program to emulate 2-d array using ` `// 1-d array ` `#include ` `#define n 3  ` `#define m 3 ` `#define max_size 100 ` `int` `main() ` `{ ` ` `  `    ``// Intialising a 2-d array ` `    ``int` `grid[n][m] = {{1, 2, 3}, ` `                      ``{4, 5, 6}, ` `                      ``{7, 8, 9}}; ` ` `  `    ``// storing elements in 1-d array ` `    ``int` `i, j, k = 0; ` `    ``int` `array[max_size]; ` `    ``for` `(i=0; i

## Java

 `// Java program to emulate 2-d array using ` `// 1-d array ` ` `  `class` `GFG ` `{ ` `    ``// Driver program ` `    ``public` `static` `void` `main(String arg[]) ` `    ``{ ` `    ``// Declaring number of rows and columns ` `        ``int` `n = ``3``, m = ``3``; ` `        ``int` `array[]=``new` `int``[``100``]; ` `     `  `        ``// Intialising a 2-d array ` `        ``int` `grid[][] = {{``1``, ``2``, ``3``}, ` `                        ``{``4``, ``5``, ``6``}, ` `                        ``{``7``, ``8``, ``9``}}; ` `     `  `        ``// storing elements in 1-d array ` `        ``int` `i, j, k = ``0``; ` `        ``for` `(i = ``0``; i < n; i++) ` `        ``{ ` `            ``for` `(j = ``0``; j < m; j++) ` `            ``{ ` `                ``k = i * m + j; ` `                ``array[k] = grid[i][j]; ` `                ``k++; ` `            ``} ` `        ``} ` `     `  `        ``// displaying elements in 1-d array ` `        ``for` `(i = ``0``; i < n; i++) ` `        ``{ ` `            ``for` `(j = ``0``; j < m; j++) ` `                ``System.out.print((array[i * m + j])+``" "``); ` `            ``System.out.print(``"\n"``); ` `        ``} ` `     `  `    ``} ` `} ` ` `  `// This code is contributed by Anant Agarwal. `

## Python3

 `# Python program to emulate 2-d  ` `# array using 1-d array ` ` `  `# Declaring number of rows and columns ` `n ``=` `3``; m ``=` `3` ` `  `array ``=` `[``0` `for` `i ``in` `range``(``100``)] ` ` `  `# Intialising a 2-d array ` `grid ``=` `[[``1``, ``2``, ``3``], ` `        ``[``4``, ``5``, ``6``], ` `        ``[``7``, ``8``, ``9``]]; ` ` `  `# storing elements in 1-d array ` `k ``=` `0` ` `  `for` `i ``in` `range``(n): ` `    ``for` `j ``in` `range``(m): ` `     `  `        ``k ``=` `i``*``m ``+` `j ` `        ``array[k] ``=` `grid[i][j] ` `        ``k ``+``=` `1` `         `  `# displaying elements in 1-d array ` `for` `i ``in` `range``(n): ` `    ``for` `j ``in` `range``(m): ` `        ``print``((array[i``*``m ``+` `j]), ``" "``, end ``=` `"") ` `    ``print``() ` `     `  `# This code is contributed by Anant Agarwal. `

## C#

 `// C# program to emulate 2-d array using ` `// 1-d array ` `using` `System; ` ` `  `class` `GFG ` `{ ` `    ``// Driver program ` `    ``public` `static` `void` `Main() ` `    ``{ ` `    ``// Declaring number of rows and columns ` `        ``int` `n = 3, m = 3; ` `        ``int` `[]array=``new` `int``; ` `     `  `        ``// Intialising a 2-d array ` `        ``int` `[,]grid = {{1, 2, 3}, ` `                        ``{4, 5, 6}, ` `                        ``{7, 8, 9}}; ` `     `  `        ``// storing elements in 1-d array ` `        ``int` `i, j, k = 0; ` `        ``for` `(i = 0; i < n; i++) ` `        ``{ ` `            ``for` `(j = 0; j < m; j++) ` `            ``{ ` `                ``k = i * m + j; ` `                ``array[k] = grid[i, j]; ` `                ``k++; ` `            ``} ` `        ``} ` `     `  `        ``// displaying elements in 1-d array ` `        ``for` `(i = 0; i < n; i++) ` `        ``{ ` `            ``for` `(j = 0; j < m; j++) ` `                ``Console.Write((array[i * m + j])+``" "``); ` `            ``Console.Write(``"\n"``); ` `        ``} ` `     `  `    ``} ` `} ` ` `  `// This code is contributed by nitin mittal `

Output:

```1  2  3
4  5  6
7  8  9
```

This article is contributed by Harsh Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.