Skip to content
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}}

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 ``#include `` ` `// 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;``    ``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 = R;``    ``MNhead->Matrix = 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; i++) {``        ``for` `(j = 0;``             ``j < Mptr->Matrix; 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);`` ` `    ``for` `(i = 0;``         ``i < MNhead->Matrix; i++) {``        ``OriginalMatrix[i]``            ``= (``int``*)``malloc``(``sizeof``(``int``)``                           ``* MNhead->Matrix);``    ``}`` ` `    ``// Initialize all the elements``    ``// in the original matrix as 0``    ``for` `(i = 0;``         ``i < MNhead->Matrix; i++) {`` ` `        ``for` `(j = 0;``             ``j < MNhead->Matrix; 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

My Personal Notes arrow_drop_up