🏆 ยอดนิยม: web//https://www.geeksforgeeks.org/convert given upper triangular matrix to d array

Convert given upper triangular Matrix to 1D Array

Difficulty Level : Expert
Last Updated : 12 Jan, 2021

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

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)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes

Jan	FEB	Mar
	26
2020	2021	2022

Related Articles

C++

Java