Emulating a 2-d array using 1-d array

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)

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 

Implementation:

C++

// C++ program to emulate 2-d array using
// 1-d array
#include<stdio.h>
#define n 3
#define m 3
#define max_size 100
int main()
{

    // Initialising 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<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++)
            printf("%d ", *(array + i*m + j));
        printf("\n");
    }

    return 0;
}

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];

        // Initialising 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)]

# Initialising 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[100];

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

Javascript

<script>

// Javascript program to emulate 2-d array using
// 1-d array

// Declaring number of rows and columns
let n = 3, m = 3;
let array = new Array(100);

// Initialising a 2-d array
let grid = [ [ 1, 2, 3 ],
             [ 4, 5, 6 ],
             [ 7, 8, 9 ] ];

// Storing elements in 1-d array
let 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++)
        document.write((array[i * m + j]) + " ");

    document.write("<br>");
}

// This code is contributed by _saurabh_jaiswal

</script>

Output

1 2 3 
4 5 6 
7 8 9 

Time Complexity: O(n*m)
Auxiliary Space: O(n*m)