Generate matrix from given Sparse Matrix using Linked List and reconstruct the Sparse Matrix

• Difficulty Level : Medium
• Last Updated : 23 Jan, 2023

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 ``#include ` `using` `namespace` `std;` `// Linked list node``struct` `SNode {``    ``int` `data;``    ``int` `Col;``    ``int` `Row;``    ``SNode* next;``};` `// Store the head pointer of the linked list``// and the size of the matrix``struct` `MatrixNode {``    ``vector > Matrix;``    ``SNode* SNPTR;``};` `// Function to create a new node``SNode* CreateList(``int` `Row, ``int` `Col, ``int` `data)``{` `    ``// Create a new node``    ``SNode* New = ``new` `SNode();` `    ``// 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``    ``SNode* 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,``                      ``vector > Matrix,``                      ``SNode* SNhead)``{``    ``MatrixNode* Mptr = MNhead;` `    ``// If the head pointer is NULL``    ``if` `(MNhead == NULL) {``        ``MNhead = ``new` `MatrixNode();``        ``MNhead->Matrix = Matrix;``        ``MNhead->SNPTR = SNhead;``    ``}` `    ``Mptr = MNhead;` `    ``// Traverse the matrix, row-wise``    ``for` `(``int` `i = 0; i < Mptr->Matrix.size(); i++) {``        ``for` `(``int` `j = 0; j < Mptr->Matrix[i].size(); j++) {``            ``// For all non-zero values, push them in linked``            ``// list``            ``if` `(Matrix[i][j] != 0)``                ``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;``    ``SNode* Sptr = MNhead->SNPTR;` `    ``// Create a 2D array``    ``vector > OriginalMatrix(``        ``MNhead->Matrix.size(),``        ``vector<``int``>(MNhead->Matrix[0].size()));` `    ``// Initialize all the elements in the original matrix as``    ``// 0``    ``for` `(i = 0; i < MNhead->Matrix.size(); i++) {``        ``for` `(j = 0; j < MNhead->Matrix[i].size(); j++) {``            ``OriginalMatrix[i][j] = 0;``        ``}``    ``}` `    ``// Print the linked list representation:``    ``cout << ``"Linked list representation:"` `<< endl;` `    ``// 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;``        ``cout << ``"("` `<< Sptr->Row << ``", "` `<< Sptr->Col``             ``<< ``", "` `<< OriginalMatrix[Sptr->Row][Sptr->Col]``             ``<< ``")->"``;``        ``// Move to the next node:``        ``Sptr = Sptr->next;``    ``}``    ``cout << ``"NULL"` `<< endl;` `    ``// Print the original matrix``    ``cout << ``"Original Matrix Re-Construction:"` `<< endl;``    ``for` `(i = 0; i < MNhead->Matrix.size(); i++) {``        ``for` `(j = 0; j < MNhead->Matrix[i].size(); j++) {``            ``cout << OriginalMatrix[i][j] << ``", "``;``        ``}``        ``cout << endl;``    ``}``}` `int` `main()``{``    ``// Initialize the head pointer of the linked list``    ``MatrixNode* MNhead = NULL;``    ``SNode* SNhead = NULL;` `    ``// Create the dense matrix``    ``vector > 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 } };` `    ``// Construct the sparse matrix``    ``MNhead = ConstructSparseMatrix(MNhead, Matrix, SNhead);` `    ``// Reconstruct the original matrix``    ``ReConstructArray(MNhead);` `    ``return` `0;``}` `// This code is contributed by lokeshmvs21.`

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[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``(``"Original 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``** OriginalMatrix;` `    ``// Sparse matrix Construction``    ``MNhead = ConstructSparseMatrix(``        ``MNhead, Matrix, SNhead);` `    ``// Sparse matrix Re-Construction``    ``ReConstructArray(MNhead);` `    ``return` `0;``}`

Java

 `// Java program for the above approach``import` `java.util.*;` `class` `Main``{``  ` `    ``// Store the size of sparse matrix``    ``static` `int` `R = ``5``;``    ``static` `int` `C = ``5``;` `    ``// Function to initialize the head of``    ``// the linked list``    ``public` `static` `MatrixNode``    ``ConstructMNhead(MatrixNode MNhead, SparseNode SNhead)``    ``{``        ``MNhead = ``new` `MatrixNode();` `        ``// 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``    ``public` `static` `SparseNode CreateList(``int` `Row, ``int` `Col,``                                        ``int` `data)``    ``{``        ``// Create a new node``        ``SparseNode New = ``new` `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``    ``public` `static` `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``    ``public` `static` `MatrixNode``    ``ConstructSparseMatrix(MatrixNode MNhead, ``int``[][] Matrix,``                          ``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] != ``0``)``                    ``MNhead = AddInList(MNhead, i, j,``                                       ``Matrix[i][j]);``            ``}``        ``}``        ``return` `MNhead;``    ``}` `    ``// Function to reconstruct the sparse``    ``// matrix using linked list``    ``public` `static` `void` `ReConstructArray(MatrixNode MNhead)``    ``{``        ``int` `i, j;``        ``SparseNode Sptr = MNhead.SNPTR;` `        ``// Create a 2D array``        ``int``[][] OriginalMatrix``            ``= ``new` `int``[MNhead.Matrix[``0``]][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 representation:``        ``System.out.println(``"Linked list representation:"``);` `        ``// 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;``            ``System.out.print(``                ``"("` `+ Sptr.Row + ``", "` `+ Sptr.Col + ``", "``                ``+ OriginalMatrix[Sptr.Row][Sptr.Col]``                ``+ ``")->"``);``            ``// Move to the next node:``            ``Sptr = Sptr.next;``        ``}``        ``System.out.println(``"NULL"``);` `        ``// Print the reconstructed matrix``        ``System.out.println(``            ``"Original Matrix Re-Construction:"``);` `        ``for` `(i = ``0``; i < R; i++) {``            ``for` `(j = ``0``; j < C; j++) {``                ``System.out.print(OriginalMatrix[i][j]``                                 ``+ ``", "``);``            ``}``            ``System.out.println(``""``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Create a head of the linked list``        ``MatrixNode MNhead = ``null``;``        ``SparseNode SNhead = ``null``;` `        ``int``[][] 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` `} };``        ``int``[][] OriginalMatrix;``        ``// Sparse matrix Construction``        ``MNhead``            ``= ConstructSparseMatrix(MNhead, Matrix, SNhead);``        ``// Sparse matrix Re-Construction``        ``ReConstructArray(MNhead);``    ``}``}` `// Linked list node``class` `SparseNode {``    ``int` `data;``    ``int` `Col;``    ``int` `Row;``    ``SparseNode next;``}` `// Store the head pointer of the linked``// list and the size of the matrix``class` `MatrixNode {``    ``int``[] Matrix = ``new` `int``[``2``];``    ``SparseNode SNPTR;``}` `// This code is contributed by Tapesh (tapeshdua420)`

Python3

 `# python code for above approach``R ``=` `5``C ``=` `5` `# linked list node``class` `SparseNode:``  ` `    ``# Function to initialize the node object``    ``def` `__init__(``self``, data, Col, Row):``        ``self``.data ``=` `data  ``# Assign data``        ``self``.Col ``=` `Col  ``# Assign Column``        ``self``.Row ``=` `Row  ``# Assign Row``        ``self``.``next` `=` `None`  `# Initialize``        ``# next as null` `# Store the head pointer of the linked``# list and the size of the matrix``class` `MatrixNode:``  ` `    ``# Function to initialize the node object``    ``def` `__init__(``self``, Matrix, SNPTR):``        ``self``.Matrix ``=` `Matrix  ``# Initialize matrix``        ``self``.SNPTR ``=` `None`  `# Initialize``        ``# SNPTR as null` `# Function to initialize the head of``# the linked list``def` `ConstructMNhead(MNhead, SNhead):``  ` `    ``# add the number of rows and``    ``# columns and add head pointer``    ``MNhead ``=` `MatrixNode([R, C], SNhead)``    ``return` `MNhead` `# Function to create a new node`  `def` `CreateList(Row, Col, data):``    ``# Create a new node``    ``New ``=` `SparseNode(data, Col, Row)``    ``return` `New` `# Function to insert a node at the``# beginning of the  linked list``def` `AddInList(MNhead, Row, Col, data):``    ``Mptr ``=` `MNhead``    ``# Create a new node``    ``New ``=` `CreateList(Row, Col, data)` `    ``# If the head is NULL, point it``    ``# to the newly created node``    ``if` `(Mptr.SNPTR ``=``=` `None``):``        ``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``def` `ConstructSparseMatrix(MNhead, Matrix,``                          ``SNhead):``    ``Mptr ``=` `MNhead` `    ``# If the head pointer is NULL``    ``if` `(MNhead ``=``=` `None``):``        ``MNhead ``=` `ConstructMNhead(``            ``MNhead, SNhead)` `    ``Mptr ``=` `MNhead` `    ``# Traverse the matrix, row-wise``    ``for` `i ``in` `range``(``0``, Mptr.Matrix[``0``]):``        ``for` `j ``in` `range``(``0``, Mptr.Matrix[``1``]):` `            ``# 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``def` `ReConstructArray(MNhead):``    ``Sptr ``=` `MNhead.SNPTR` `    ``# Create a 2D array``    ``OriginalMatrix ``=` `[]` `    ``# Initialize all the elements``    ``# in the original matrix as 0``    ``for` `i ``in` `range``(``0``, MNhead.Matrix[``0``]):``        ``OriginalMatrix.append([])``        ``for` `j ``in` `range``(``0``, MNhead.Matrix[``1``]):``            ``OriginalMatrix[i].append(``0``)` `    ``# Print the linked list``    ``print``(``"Linked list represe"``          ``"ntation:\n"``)` `    ``# Iterate while sptr pointer is not NULL``    ``while` `(Sptr !``=` `None``):` `        ``# Update the element in the``        ``# original matrix and print``        ``# the current node``        ``OriginalMatrix[Sptr.Row][Sptr.Col] ``=` `Sptr.data` `        ``print``(``"("``, Sptr.Row, ``","``, Sptr.Col, ``","``,``              ``OriginalMatrix[Sptr.Row][Sptr.Col], ``")->"``, end``=``" "``)` `        ``# Move to the next node``        ``Sptr ``=` `Sptr.``next``    ``print``(``"None\n"``)` `    ``# Print the reconstructed matrix``    ``print``(``"Original Matrix Re"``          ``"-Construction:\n"``)` `    ``for` `i ``in` `range``(``0``, R):``        ``for` `j ``in` `range``(``0``, C):``            ``print``(OriginalMatrix[i][j], end``=``" "``)``        ``print``(``"\n"``)`  `# Create a head of the linked list` `# Driver Code``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``]]` `MNhead ``=` `None``SNhead ``=` `None``# Sparse matrix Construction``MNhead ``=` `ConstructSparseMatrix(MNhead, Matrix, SNhead)` `# Sparse matrix Re-Construction``ReConstructArray(MNhead)` `# This code is contributed by rj13to`

C#

 `// C# program for the above approach``using` `System;` `class` `Program {` `    ``// Store the size of sparse matrix``    ``static` `int` `R = 5;``    ``static` `int` `C = 5;` `    ``// Function to initialize the head of``    ``// the linked list``    ``public` `static` `MatrixNode``    ``ConstructMNhead(MatrixNode MNhead, SparseNode SNhead)``    ``{``        ``MNhead = ``new` `MatrixNode();` `        ``// 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``    ``public` `static` `SparseNode CreateList(``int` `Row, ``int` `Col,``                                        ``int` `data)``    ``{``        ``// Create a new node``        ``SparseNode New = ``new` `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;` `        ``return` `New;``    ``}` `    ``// Function to insert a node at the``    ``// beginning of the  linked list``    ``public` `static` `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``    ``public` `static` `MatrixNode``    ``ConstructSparseMatrix(MatrixNode MNhead, ``int``[, ] Matrix,``                          ``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] != 0)``                    ``MNhead = AddInList(MNhead, i, j,``                                       ``Matrix[i, j]);``            ``}``        ``}``        ``return` `MNhead;``    ``}` `    ``public` `static` `void` `ReConstructArray(MatrixNode MNhead)``    ``{``        ``int` `i, j;``        ``SparseNode Sptr = MNhead.SNPTR;` `        ``// Create a 2D array``        ``int``[, ] OriginalMatrix``            ``= ``new` `int``[MNhead.Matrix[0], 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 representation:``        ``Console.WriteLine(``"Linked list representation:"``);` `        ``// 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;``            ``Console.Write(``                ``"("` `+ Sptr.Row + ``", "` `+ Sptr.Col + ``", "``                ``+ OriginalMatrix[Sptr.Row, Sptr.Col]``                ``+ ``")->"``);``            ``// Move to the next node:``            ``Sptr = Sptr.next;``        ``}``        ``Console.WriteLine(``"NULL"``);` `        ``// Print the reconstructed matrix``        ``Console.WriteLine(``            ``"Original Matrix Re-Construction:"``);` `        ``for` `(i = 0; i < R; i++) {``            ``for` `(j = 0; j < C; j++) {``                ``Console.Write(OriginalMatrix[i, j] + ``", "``);``            ``}``            ``Console.WriteLine(``""``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``// Create a head of the linked list``        ``MatrixNode MNHead = ``null``;``        ``SparseNode SNHead = ``null``;``        ``int``[, ] Matrix = ``new` `int``[, ] { { 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 } };` `        ``// Create a head of the linked list``        ``MNHead``            ``= ConstructSparseMatrix(MNHead, Matrix, SNHead);``        ``// Sparse matrix Re-Construction``        ``ReConstructArray(MNHead);``    ``}``}` `// Linked list node``class` `SparseNode {``    ``public` `int` `data;``    ``public` `int` `Col;``    ``public` `int` `Row;``    ``public` `SparseNode next;``}` `// Store the head pointer of the linked``// list and the size of the matrix``class` `MatrixNode {``    ``public` `int``[] Matrix = ``new` `int``[2];``    ``public` `SparseNode SNPTR;``}` `// This code is contributed by Tapesh (tapeshdua420)`

Javascript

 `  ``// JavaScript code for the above approach``  ``class SparseNode``  ``{``      ` `  ``// linked list node``  ``constructor(data, Col, Row) {``    ``this``.data = data; ``// Assign data``    ``this``.Col = Col; ``// Assign Column``    ``this``.Row = Row; ``// Assign Row``    ``this``.next = ``null``; ``// Initialize next as null``  ``}``}` `class MatrixNode {``  ``constructor(Matrix, SNPTR) {``    ``this``.Matrix = Matrix; ``// Initialize matrix``    ``this``.SNPTR = ``null``; ``// Initialize SNPTR as null``  ``}``}` `const R = 5;``const C = 5;` `function` `ConstructMNhead(MNhead, SNhead) {``  ``// Function to initialize the head of the linked list``  ``MNhead = ``new` `MatrixNode([R, C], SNhead);``  ``return` `MNhead;``}` `function` `CreateList(Row, Col, data) {``  ``// Function to create a new node``  ``const New = ``new` `SparseNode(data, Col, Row);``  ``return` `New;``}` `function` `AddInList(MNhead, Row, Col, data) {``  ``let Mptr = MNhead;``  ``const New = CreateList(Row, Col, data);` `  ``// Function to insert a node at the beginning of the linked list``  ``// 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` `ConstructSparseMatrix(MNhead, Matrix) {``  ``// Function to construct the sparse matrix using linked list``  ``let Mptr = MNhead;` `  ``// If the head pointer is NULL``  ``if` `(MNhead === ``null``) {``    ``MNhead = ConstructMNhead(MNhead);``  ``}``  ``Mptr = MNhead;` `  ``// Traverse the matrix, row-wise``  ``for` `(let i = 0; i < Mptr.Matrix[0]; i++) {``    ``for` `(let 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` `ReConstructArray(MNhead) {``  ``let Sptr = MNhead.SNPTR;` `  ``// Create a 2D array``  ``const OriginalMatrix = [];` `  ``// Initialize all the elements in the original matrix as 0``  ``for` `(let i = 0; i < MNhead.Matrix[0]; i++) {``    ``OriginalMatrix.push([]);``    ``for` `(let j = 0; j < MNhead.Matrix[1]; j++) {``      ``OriginalMatrix[i].push(0);``    ``}``  ``}` `  ``// Print the linked list representation``  ``console.log(``"Linked list representation:"``);``  ``console.log(``"
"``)``  ``// 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;``    ``console.log(`(\${Sptr.Row}, \${Sptr.Col}, \${OriginalMatrix[Sptr.Row][Sptr.Col]})->`);` `    ``// Move to the next node``    ``Sptr = Sptr.next;``  ``}``  ``console.log(``"None"``);``  ``console.log(``"
"``)` `  ``// Print the reconstructed matrix``  ``console.log(``"Original Matrix Re-Construction:"``);``  ``console.log(``"
"``)``  ``for` `(let i = 0; i < R; i++) {``    ``for` `(let j = 0; j < C; j++) {``      ``console.log(OriginalMatrix[i][j]+``" "``);``    ``}``   ``console.log(``"
"``)``  ``}``}``// Create a 2D matrix``const 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]]` `// Create a head of the linked list``let MNhead = ``null``;` `// Construct the sparse matrix``MNhead = ConstructSparseMatrix(MNhead, Matrix);` `// Re-construct the original matrix``ReConstructArray(MNhead);` `// This code is contributed by lokeshpotta20.`

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

My Personal Notes arrow_drop_up