# Convert given upper triangular Matrix to 1D Array

• Difficulty Level : Expert
• Last Updated : 20 Jun, 2022

Given an upper triangular matrix M[][] of dimensions N * N, the task is to convert it into an one-dimensional array storing only non-zero elements from the matrix.

Examples:

Input: M[][] = {{1, 2, 3, 4}, {0, 5, 6, 7}, {0, 0, 8, 9}, {0, 0, 0, 10}}
Output: Row-wise: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
Column-wise: {1, 2, 5, 3, 6, 8, 4, 7, 9, 10}
Explanation: All the non-zero elements of the matrix are {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Input: M[][] = {{1, 2, 3, }, {0, 4, 5}, {0, 0, 6}}
Output: Row-wise: {1, 2, 3, 4, 5, 6}
Column-wise: {1, 2, 4, 3, 5, 6}
Explanation: All the non-zero elements of the matrix are {1, 2, 3, 4, 5, 6}

Approach: To convert given 2-dimensional matrix to a 1-dimensional array, following two methods are used:

Row – Major Order:

• In this method, elements are stored such that consecutive elements of a row are placed consecutively in the array.

ROW-MAJOR ORDER

• The following formula is used to find the correct position of non-zero matrix elements in the array:

Element present at index (i, j) in the matrix is placed at [N * (i – 1) – (i – 2) * (i -1) /2] + (j – i)
where 1 â‰¤ i, j â‰¤ N and i â‰¤ j

Column-Major Order:

• In this method, elements are stored such that consecutive elements of a column are placed consecutively in the array.

COLUMN-MAJOR ORDER

• The following formula is used to find out the correct position of non-zero matrix elements:

Element present at index (i, j) in the matrix is placed at [j * (j – 1) / 2] + i – 1
where 1 â‰¤ i, j â‰¤ N and i â‰¤ j.

Follow the steps below to solve the problem:

• Initialize an array A[] to store non-zero matrix elements.
• Traverse the matrix M[][].
• Find the correct indices of non-zero matrix elements in the array A[] using the above formulas.
• Place the non-zero elements at the correct indices of A[] accordingly.
• Finally, print the array A[] obtained.

Below is the implementation of the above approach:

## C++

 `// C++ Program to convert a given``// upper triangular matrix to 1D array` `#include ``using` `namespace` `std;` `// Create a class of Upper``// Triangular Matrix``class` `UTMatrix {` `private``:``    ``// Size of Matrix``    ``int` `n;` `    ``// Pointer``    ``int``* A;` `    ``// Stores count of``    ``// non-zero elements``    ``int` `tot;` `public``:``    ``// Constructor``    ``UTMatrix(``int` `N)``    ``{``        ``this``->n = N;``        ``tot = N * (N + 1) / 2;``        ``A = ``new` `int``[N * (N + 1) / 2];``    ``}` `    ``// Destructor``    ``~UTMatrix() { ``delete``[] A; }` `    ``// Function to display array``    ``void` `Display(``bool` `row = ``true``);` `    ``// Function to generate array in``    ``// Row - Major order``    ``void` `setRowMajor(``int` `i, ``int` `j, ``int` `x);` `    ``// Function to generate array in``    ``// Column - Major order``    ``void` `setColMajor(``int` `i, ``int` `j, ``int` `x);` `    ``// Function to return size of array``    ``int` `getN() { ``return` `n; }``};` `// Function to generate array from given matrix``// by storing elements in column major order``void` `UTMatrix::setColMajor(``int` `i, ``int` `j, ``int` `x)``{``    ``if` `(i <= j) {``        ``int` `index = ((j * (j - 1)) / 2) + i - 1;``        ``A[index] = x;``    ``}``}` `// Function to generate array from given matrix``// by storing elements in row major order``void` `UTMatrix::setRowMajor(``int` `i, ``int` `j, ``int` `x)``{``    ``if` `(i <= j) {``        ``int` `index``            ``= (n * (i - 1) - (((i - 2) * (i - 1)) / 2))``              ``+ (j - i);``        ``A[index] = x;``    ``}``}` `// Function to display array elements``void` `UTMatrix::Display(``bool` `row)``{``    ``for` `(``int` `i = 0; i < tot; i++) {``        ``cout << A[i] << ``" "``;``    ``}``    ``cout << endl;``}` `// Function to generate and``// display array in Row-Major Order``void` `displayRowMajor(``int` `N)``{``    ``UTMatrix rm(N);` `    ``// Generate array in``    ``// row-major form``    ``rm.setRowMajor(1, 1, 1);``    ``rm.setRowMajor(1, 2, 2);``    ``rm.setRowMajor(1, 3, 3);``    ``rm.setRowMajor(1, 4, 4);``    ``rm.setRowMajor(2, 2, 5);``    ``rm.setRowMajor(2, 3, 6);``    ``rm.setRowMajor(2, 4, 7);``    ``rm.setRowMajor(3, 3, 8);``    ``rm.setRowMajor(3, 4, 9);``    ``rm.setRowMajor(4, 4, 10);` `    ``// Display array elements in``    ``// row-major order``    ``cout << ``"Row-Wise: "``;` `    ``rm.Display();``}` `// Function to generate and display``// array in Column-Major Order``void` `displayColMajor(``int` `N)``{``    ``UTMatrix cm(N);` `    ``// Generate array in``    ``// column-major form``    ``cm.setColMajor(1, 1, 1);``    ``cm.setColMajor(1, 2, 2);``    ``cm.setColMajor(1, 3, 3);``    ``cm.setColMajor(1, 4, 4);``    ``cm.setColMajor(2, 2, 5);``    ``cm.setColMajor(2, 3, 6);``    ``cm.setColMajor(2, 4, 7);``    ``cm.setColMajor(3, 3, 8);``    ``cm.setColMajor(3, 4, 9);``    ``cm.setColMajor(4, 4, 10);` `    ``// Display array elements in``    ``// column-major form``    ``cout << ``"Column-wise: "``;``    ``cm.Display(``false``);``}` `// Driver Code``int` `main()``{``    ``// Size of row or column``    ``// of square matrix``    ``int` `N = 4;` `    ``displayRowMajor(N);` `    ``displayColMajor(N);` `    ``return` `0;``}`

## Java

 `// Java program to convert a given``// upper triangular matrix to 1D array` `// Create a class of Upper``// Triangular Matrix``class` `UTMatrix{``    ` `// Size of Matrix``private` `int` `n;` `private` `int``[] A = ``new` `int``[n];` `// Stores count of``// non-zero elements``private` `int` `tot;` `// Constructor``public` `UTMatrix(``int` `N)``{``    ``this``.n = N;``    ``tot = N * (N + ``1``) / ``2``;``    ``A = ``new` `int``[N * (N + ``1``) / ``2``];``}` `// Function to display array``void` `Display(``boolean` `row)``{``    ``for``(``int` `i = ``0``; i < tot; i++)``    ``{``        ``System.out.print(A[i] + ``" "``);``    ``}``    ``System.out.println();``}` `// Function to generate array in``// Row - Major order``void` `setRowMajor(``int` `i, ``int` `j, ``int` `x)``{``    ``if` `(i <= j)``    ``{``        ``int` `index = (n * (i - ``1``) - (((i - ``2``) *``                         ``(i - ``1``)) / ``2``)) + (j - i);``        ``A[index] = x;``    ``}``}` `// Function to generate array in``// Column - Major order``void` `setColMajor(``int` `i, ``int` `j, ``int` `x)``{``    ``if` `(i <= j) {``        ``int` `index = ((j * (j - ``1``)) / ``2``) + i - ``1``;``        ``A[index] = x;``    ``}``}` `// Function to return size of array``int` `getN()``{``    ``return` `n;``}``}` `class` `GFG{` `// Function to generate and``// display array in Row-Major Order``static` `void` `displayRowMajor(``int` `N)``{``    ``UTMatrix rm = ``new` `UTMatrix(N);` `    ``// Generate array in``    ``// row-major form``    ``rm.setRowMajor(``1``, ``1``, ``1``);``    ``rm.setRowMajor(``1``, ``2``, ``2``);``    ``rm.setRowMajor(``1``, ``3``, ``3``);``    ``rm.setRowMajor(``1``, ``4``, ``4``);``    ``rm.setRowMajor(``2``, ``2``, ``5``);``    ``rm.setRowMajor(``2``, ``3``, ``6``);``    ``rm.setRowMajor(``2``, ``4``, ``7``);``    ``rm.setRowMajor(``3``, ``3``, ``8``);``    ``rm.setRowMajor(``3``, ``4``, ``9``);``    ``rm.setRowMajor(``4``, ``4``, ``10``);` `    ``// Display array elements in``    ``// row-major order``    ``System.out.print(``"Row-Wise: "``);` `    ``rm.Display(``false``);``}` `// Function to generate and display``// array in Column-Major Order``static` `void` `displayColMajor(``int` `N)``{``    ``UTMatrix cm = ``new` `UTMatrix(N);` `    ``// Generate array in``    ``// column-major form``    ``cm.setColMajor(``1``, ``1``, ``1``);``    ``cm.setColMajor(``1``, ``2``, ``2``);``    ``cm.setColMajor(``1``, ``3``, ``3``);``    ``cm.setColMajor(``1``, ``4``, ``4``);``    ``cm.setColMajor(``2``, ``2``, ``5``);``    ``cm.setColMajor(``2``, ``3``, ``6``);``    ``cm.setColMajor(``2``, ``4``, ``7``);``    ``cm.setColMajor(``3``, ``3``, ``8``);``    ``cm.setColMajor(``3``, ``4``, ``9``);``    ``cm.setColMajor(``4``, ``4``, ``10``);` `    ``// Display array elements in``    ``// column-major form``    ``System.out.print(``"Column-wise: "``);``    ``cm.Display(``false``);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Size of row or column``    ``// of square matrix``    ``int` `N = ``4``;` `    ``displayRowMajor(N);` `    ``displayColMajor(N);``}``}` `// This code is contributed by dharanendralv23`

## Javascript

 ``

Output:

```Row-Wise: 1 2 3 4 5 6 7 8 9 10
Column-wise: 1 2 5 3 6 8 4 7 9 10```

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

My Personal Notes arrow_drop_up