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