将给定的上三角矩阵转换为一维数组

给定大小为N * N的上三角矩阵M [] [] ，任务是将其转换为仅存储矩阵中非零元素的一维数组。

例子：

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}

方法：要将给定的二维矩阵转换为一维数组，请使用以下两种方法：

行–主要订单：

• 在这种方法中，存储元素，以便将一行中的连续元素连续放置在数组中。

主要订单

• 以下公式用于查找数组中非零矩阵元素的正确位置：

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

列主要订单：

• 在此方法中，存储元素以使一列的连续元素连续放置在数组中。

列主要订单

• 以下公式用于找出非零矩阵元素的正确位置：

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.

请按照以下步骤解决问题：

• 初始化数组A []以存储非零矩阵元素。
• 遍历矩阵M [] [] 。
• 使用上述公式在数组A []中找到正确的非零矩阵元素索引。
• 相应地将非零元素放在A []的正确索引处。
• 最后，打印获得的数组A [] 。

下面是上述方法的实现：

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

输出：

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

时间复杂度： O(N * N)
辅助空间： O(N * N)