Skip to content
Related Articles

Related Articles

Generate matrix from given Sparse Matrix using Linked List and reconstruct the Sparse Matrix
  • Last Updated : 19 Apr, 2021

Given a sparse matrix mat[][] of dimensions N*M, the task is to construct and represent the original matrix using a Linked List and reconstruct the givensparse matrix.

Examples:

Input: mat[][] = {{0, 1, 0, 0, 0}, {0, 1, 0, 0, 0}, {0, 0, 2, 0, 0}, {0, 3, 0, 0, 4}, {0, 0, 5, 0, 0}}
Output:
Linked list representation: (4, 2, 5) → (3, 4, 4) → (3, 1, 3) → (2, 2, 2) → (1, 1, 1) → (0, 1, 1) → NULL
Original matrix:
{{0, 1, 0, 0, 0},
{0, 1, 0, 0, 0},
{0, 0, 2, 0, 0},
{0, 3, 0, 0, 4}
{0, 0, 5, 0, 0}}

Input: mat[][] = {{0, 0, 0, 4, 0}, {0, 1, 0, 0, 0}}
Output:
Linked list representation: (1, 1, 1) → (0, 3, 4) → NULL
Original matrix:
{{0, 0, 0, 4, 0},
{0, 1, 0, 0, 0}}

Approach: The given problem can be solved by storing the row index, column index, its value, and the next pointer of all non-zero elements in the node of the linked list. Follow the steps below to solve the problem: 



Below is the implementation of the above approach:

C




// C program for the above approach
  
#include <stdio.h>
#include <stdlib.h>
  
// Store the size of sparse matrix
#define R 5
#define C 5
  
// Linked list node
typedef struct SNode {
    int data;
    int Col;
    int Row;
    struct SNode* next;
} SparseNode;
  
// Store the head pointer of the linked
// list and the size of the matrix
typedef struct MNode {
    int Matrix[2];
    SparseNode* SNPTR;
} MatrixNode;
  
// Function to initialize the head of
// the linked list
MatrixNode* ConstructMNhead(
    MatrixNode* MNhead, SparseNode* SNhead)
{
  
    MNhead = (MatrixNode*)malloc(sizeof(MNhead));
  
    // Update the number of rows and
    // columns and update head pointer
    MNhead->Matrix[0] = R;
    MNhead->Matrix[1] = C;
    MNhead->SNPTR = SNhead;
  
    return MNhead;
}
  
// Function to create a new node
SparseNode* CreateList(int Row, int Col,
                       int data)
{
  
    // Create a new node
    SparseNode* New
        = (SparseNode*)malloc(sizeof(SparseNode));
  
    // Update the value and the row
    // and column index and set the
    // next pointer to NULL
    New->data = data;
    New->Col = Col;
    New->Row = Row;
    New->next = NULL;
  
    return New;
}
  
// Function to insert a node at the
// beginning of the  linked list
MatrixNode* AddInList(
    MatrixNode* MNhead, int Row,
    int Col, int data)
{
    MatrixNode* Mptr = MNhead;
  
    // Create a new node
    SparseNode* New = CreateList(
        Row, Col, data);
  
    // If the head is NULL, point it
    // to the newly created node
    if (Mptr->SNPTR == NULL) {
        Mptr->SNPTR = New;
        return MNhead;
    }
  
    // Insert this node at beginning
    New->next = Mptr->SNPTR;
  
    // Update the head pointer
    Mptr->SNPTR = New;
  
    return MNhead;
}
  
// Function to construct the sparse
// matrix using linked list
MatrixNode* ConstructSparseMatrix(
    MatrixNode* MNhead, int Matrix[R][C],
    SparseNode* SNhead)
{
    int i, j;
    MatrixNode* Mptr = MNhead;
  
    // If the head pointer is NULL
    if (MNhead == NULL) {
        MNhead = ConstructMNhead(
            MNhead, SNhead);
    }
  
    Mptr = MNhead;
  
    // Traverse the matrix, row-wise
    for (i = 0;
         i < Mptr->Matrix[0]; i++) {
        for (j = 0;
             j < Mptr->Matrix[1]; j++) {
  
            // For all non-zero values,
            // push them in linked list
            if (Matrix[i][j])
                MNhead = AddInList(
                    MNhead, i, j,
                    Matrix[i][j]);
        }
    }
  
    return MNhead;
}
  
// Function to reconstruct the sparse
// matrix using linked list
void ReConstructArray(MatrixNode* MNhead)
{
    int i, j;
    SparseNode* Sptr = MNhead->SNPTR;
  
    // Create a 2D array
    int** OriginalMatrix
  
        = (int**)malloc(sizeof(int*)
                        * MNhead->Matrix[0]);
  
    for (i = 0;
         i < MNhead->Matrix[0]; i++) {
        OriginalMatrix[i]
            = (int*)malloc(sizeof(int)
                           * MNhead->Matrix[1]);
    }
  
    // Initialize all the elements
    // in the original matrix as 0
    for (i = 0;
         i < MNhead->Matrix[0]; i++) {
  
        for (j = 0;
             j < MNhead->Matrix[1]; j++) {
            OriginalMatrix[i][j] = 0;
        }
    }
  
    // Print the linked list
    printf("Linked list represe"
           "ntation:\n");
  
    // Iterate while sptr pointer is not NULL
    while (Sptr != NULL) {
  
        // Update the element in the
        // original matrix and print
        // the current node
        OriginalMatrix[Sptr->Row][Sptr->Col]
            = Sptr->data;
  
        printf("(%d, %d, %d)->",
               Sptr->Row, Sptr->Col,
               OriginalMatrix[Sptr->Row][Sptr->Col]);
  
        // Move to the next node
        Sptr = Sptr->next;
    }
    printf("NULL\n");
  
    // Print the reconstructed matrix
    printf("Orignal Matrix Re"
           "-Construction:\n");
  
    for (i = 0; i < R; i++) {
        for (j = 0; j < C; j++) {
            printf("%d, ", OriginalMatrix[i][j]);
        }
        printf("\n");
    }
}
  
// Create a head of the linked list
MatrixNode* MNhead = NULL;
SparseNode* SNhead = NULL;
  
// Driver Code
int main()
{
    int Matrix[R][C] = { { 0, 1, 0, 0, 0 },
                         { 0, 1, 0, 0, 0 },
                         { 0, 0, 2, 0, 0 },
                         { 0, 3, 0, 0, 4 },
                         { 0, 0, 5, 0, 0 } };
    int** OrignalMatrix;
  
    // Sparse matrix Construction
    MNhead = ConstructSparseMatrix(
        MNhead, Matrix, SNhead);
  
    // Sparse matrix Re-Construction
    ReConstructArray(MNhead);
  
    return 0;
}
Output:
Linked list representation:
(4, 2, 5)->(3, 4, 4)->(3, 1, 3)->(2, 2, 2)->(1, 1, 1)->(0, 1, 1)->NULL
Orignal Matrix Re-Construction:
0, 1, 0, 0, 0, 
0, 1, 0, 0, 0, 
0, 0, 2, 0, 0, 
0, 3, 0, 0, 4, 
0, 0, 5, 0, 0,


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

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

 

My Personal Notes arrow_drop_up
Recommended Articles
Page :