Open In App

Sparse Matrix and its representations | Set 1 (Using Arrays and Linked Lists)

Improve
Improve
Like Article
Like
Save
Share
Report

A matrix is a two-dimensional data object made of m rows and n columns, therefore having total m x n values. If most of the elements of the matrix have 0 value, then it is called a sparse matrix.

Why to use Sparse Matrix instead of simple matrix ?

  • Storage: There are lesser non-zero elements than zeros and thus lesser memory can be used to store only those elements.
  • Computing time: Computing time can be saved by logically designing a data structure traversing only non-zero elements..

Example: 

0 0 3 0 4            
0 0 5 7 0
0 0 0 0 0
0 2 6 0 0

Representing a sparse matrix by a 2D array leads to wastage of lots of memory as zeroes in the matrix are of no use in most of the cases. So, instead of storing zeroes with non-zero elements, we only store non-zero elements. This means storing non-zero elements with triples- (Row, Column, value). 

Sparse Matrix Representations can be done in many ways following are two common representations: 

  1. Array representation
  2. Linked list representation

Method 1: Using Arrays:

2D array is used to represent a sparse matrix in which there are three rows named as 

  • Row: Index of row, where non-zero element is located
  • Column: Index of column, where non-zero element is located
  • Value: Value of the non zero element located at index – (row,column)

Sparse Matrix Array Representation

Implementation:

C++




// C++ program for Sparse Matrix Representation
// using Array
#include <iostream>
using namespace std;
 
int main()
{
    // Assume 4x5 sparse matrix
    int sparseMatrix[4][5] =
    {
        {0 , 0 , 3 , 0 , 4 },
        {0 , 0 , 5 , 7 , 0 },
        {0 , 0 , 0 , 0 , 0 },
        {0 , 2 , 6 , 0 , 0 }
    };
 
    int size = 0;
    for (int i = 0; i < 4; i++)
        for (int j = 0; j < 5; j++)
            if (sparseMatrix[i][j] != 0)
                size++;
 
    // number of columns in compactMatrix (size) must be
    // equal to number of non - zero elements in
    // sparseMatrix
    int compactMatrix[3][size];
 
    // Making of new matrix
    int k = 0;
    for (int i = 0; i < 4; i++)
        for (int j = 0; j < 5; j++)
            if (sparseMatrix[i][j] != 0)
            {
                compactMatrix[0][k] = i;
                compactMatrix[1][k] = j;
                compactMatrix[2][k] = sparseMatrix[i][j];
                k++;
            }
 
    for (int i=0; i<3; i++)
    {
        for (int j=0; j<size; j++)
            cout <<" "<< compactMatrix[i][j];
 
        cout <<"\n";
    }
    return 0;
}
 
// this code is contributed by shivanisinghss2110


C




// C++ program for Sparse Matrix Representation
// using Array
#include<stdio.h>
 
int main()
{
    // Assume 4x5 sparse matrix
    int sparseMatrix[4][5] =
    {
        {0 , 0 , 3 , 0 , 4 },
        {0 , 0 , 5 , 7 , 0 },
        {0 , 0 , 0 , 0 , 0 },
        {0 , 2 , 6 , 0 , 0 }
    };
 
    int size = 0;
    for (int i = 0; i < 4; i++)
        for (int j = 0; j < 5; j++)
            if (sparseMatrix[i][j] != 0)
                size++;
 
    // number of columns in compactMatrix (size) must be
    // equal to number of non - zero elements in
    // sparseMatrix
    int compactMatrix[3][size];
 
    // Making of new matrix
    int k = 0;
    for (int i = 0; i < 4; i++)
        for (int j = 0; j < 5; j++)
            if (sparseMatrix[i][j] != 0)
            {
                compactMatrix[0][k] = i;
                compactMatrix[1][k] = j;
                compactMatrix[2][k] = sparseMatrix[i][j];
                k++;
            }
 
    for (int i=0; i<3; i++)
    {
        for (int j=0; j<size; j++)
            printf("%d ", compactMatrix[i][j]);
 
        printf("\n");
    }
    return 0;
}


Java




// Java program for Sparse Matrix Representation
// using Array
class GFG
{
 
    public static void main(String[] args)
    {
        int sparseMatrix[][]
                = {
                    {0, 0, 3, 0, 4},
                    {0, 0, 5, 7, 0},
                    {0, 0, 0, 0, 0},
                    {0, 2, 6, 0, 0}
                };
 
        int size = 0;
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 5; j++)
            {
                if (sparseMatrix[i][j] != 0)
                {
                    size++;
                }
            }
        }
 
        // number of columns in compactMatrix (size) must be
        // equal to number of non - zero elements in
        // sparseMatrix
        int compactMatrix[][] = new int[3][size];
 
        // Making of new matrix
        int k = 0;
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 5; j++)
            {
                if (sparseMatrix[i][j] != 0)
                {
                    compactMatrix[0][k] = i;
                    compactMatrix[1][k] = j;
                    compactMatrix[2][k] = sparseMatrix[i][j];
                    k++;
                }
            }
        }
 
        for (int i = 0; i < 3; i++)
        {
            for (int j = 0; j < size; j++)
            {
                System.out.printf("%d ", compactMatrix[i][j]);
            }
            System.out.printf("\n");
        }
    }
}
 
/* This code contributed by PrinciRaj1992 */


Python3




# Python program for Sparse Matrix Representation
# using arrays
 
# assume a sparse matrix of order 4*5
# let assume another matrix compactMatrix
# now store the value,row,column of arr1 in sparse matrix compactMatrix
 
sparseMatrix = [[0,0,3,0,4],[0,0,5,7,0],[0,0,0,0,0],[0,2,6,0,0]]
 
# initialize size as 0
size = 0
 
for i in range(4):
    for j in range(5):
        if (sparseMatrix[i][j] != 0):
            size += 1
 
# number of columns in compactMatrix(size) should
# be equal to number of non-zero elements in sparseMatrix
rows, cols = (3, size)
compactMatrix = [[0 for i in range(cols)] for j in range(rows)]
 
k = 0
for i in range(4):
    for j in range(5):
        if (sparseMatrix[i][j] != 0):
            compactMatrix[0][k] = i
            compactMatrix[1][k] = j
            compactMatrix[2][k] = sparseMatrix[i][j]
            k += 1
 
for i in compactMatrix:
    print(i)
 
# This code is contributed by MRINALWALIA


C#




// C# program for Sparse Matrix Representation
// using Array
 
using System;
 
class Program {
    static void Main(string[] args)
    {
        // Assume 4x5 sparse matrix
        int[, ] sparseMatrix
            = new int[4, 5] { { 0, 0, 3, 0, 4 },
                              { 0, 0, 5, 7, 0 },
                              { 0, 0, 0, 0, 0 },
                              { 0, 2, 6, 0, 0 } };
        int size = 0;
        for (int i = 0; i < 4; i++)
            for (int j = 0; j < 5; j++)
                if (sparseMatrix[i, j] != 0)
                    size++;
 
        // number of columns in compactMatrix (size) must be
        // equal to number of non - zero elements in
        // sparseMatrix
        int[, ] compactMatrix = new int[3, size];
 
        // Making of new matrix
        int k = 0;
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 5; j++)
                if (sparseMatrix[i, j] != 0) {
                    compactMatrix[0, k] = i;
                    compactMatrix[1, k] = j;
                    compactMatrix[2, k]
                        = sparseMatrix[i, j];
                    k++;
                }
        }
 
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < size; j++)
                Console.Write(" " + compactMatrix[i, j]);
            Console.WriteLine();
        }
    }
}
// This code is contributed by Tapesh(tapeshdua420)


Javascript




//JS  program for Sparse Matrix Representation
// using Array
 
    // Assume 4x5 sparse matrix
    let sparseMatrix =
    [
        [0 , 0 , 3 , 0 , 4 ],
        [0 , 0 , 5 , 7 , 0 ],
        [0 , 0 , 0 , 0 , 0 ],
        [0 , 2 , 6 , 0 , 0 ]
    ];
 
    let size = 0;
    for (let i = 0; i < 4; i++)
        for (let j = 0; j < 5; j++)
            if (sparseMatrix[i][j] != 0)
                size++;
 
    // number of columns in compactMatrix (size) must be
    // equal to number of non - zero elements in
    // sparseMatrix
    let compactMatrix = new Array(3);
    for (var i = 0; i < 3; i++)
        compactMatrix[i] = new Array(size);
 
 
    // Making of new matrix
    let k = 0;
    for (let i = 0; i < 4; i++)
        for (let j = 0; j < 5; j++)
            if (sparseMatrix[i][j] != 0)
            {
                compactMatrix[0][k] = i;
                compactMatrix[1][k] = j;
                compactMatrix[2][k] = sparseMatrix[i][j];
                k++;
            }
 
    for (let i=0; i<3; i++)
    {
        for (let j=0; j<size; j++)
            process.stdout.write(" " + compactMatrix[i][j]);
 
        console.log()
    }
 
 
// this code is contributed by phasing17


Output

 0 0 1 1 3 3
 2 4 2 3 1 2
 3 4 5 7 2 6

Time Complexity:  O(NM), where N is the number of rows in the sparse matrix, and M is the number of columns in the sparse matrix.

Auxiliary Space: O(NM), where N is the number of rows in the sparse matrix, and M is the number of columns in the sparse matrix.

Method 2: Using Linked Lists
In linked list, each node has four fields. These four fields are defined as: 

  • Row: Index of row, where non-zero element is located
  • Column: Index of column, where non-zero element is located
  • Value: Value of the non zero element located at index – (row,column)
  • Next node: Address of the next node

Sparse-Matrix-Linked-List 2

C++




// C++ program for sparse matrix representation.
// Using Link list
#include<iostream>
using namespace std;
 
// Node class to represent link list
class Node
{
    public:
    int row;
    int col;
    int data;
    Node *next;
};
 
// Function to create new node
void create_new_node(Node **p, int row_index,
                     int col_index, int x)
{
    Node *temp = *p;
    Node *r;
     
    // If link list is empty then
    // create first node and assign value.
    if (temp == NULL)
    {
        temp = new Node();
        temp->row = row_index;
        temp->col = col_index;
        temp->data = x;
        temp->next = NULL;
        *p = temp;
    }
     
    // If link list is already created
    // then append newly created node
    else
    {
        while (temp->next != NULL)  
            temp = temp->next;
             
        r = new Node();
        r->row = row_index;
        r->col = col_index;
        r->data = x;
        r->next = NULL;
        temp->next = r;
    }
}
 
// Function prints contents of linked list
// starting from start
void printList(Node *start)
{
    Node *ptr = start;
    cout << "row_position:";
    while (ptr != NULL)
    {
        cout << ptr->row << " ";
        ptr = ptr->next;
    }
    cout << endl;
    cout << "column_position:";
 
    ptr = start;
    while (ptr != NULL)
    {
        cout << ptr->col << " ";
        ptr = ptr->next;
    }
    cout << endl;
    cout << "Value:";
    ptr = start;
     
    while (ptr != NULL)
    {
        cout << ptr->data << " ";
        ptr = ptr->next;
    }
}
 
// Driver Code
int main()
{
     
    // 4x5 sparse matrix
    int sparseMatrix[4][5] = { { 0 , 0 , 3 , 0 , 4 },
                               { 0 , 0 , 5 , 7 , 0 },
                               { 0 , 0 , 0 , 0 , 0 },
                               { 0 , 2 , 6 , 0 , 0 } };
     
    // Creating head/first node of list as NULL
    Node *first = NULL;
    for(int i = 0; i < 4; i++)
    {
        for(int j = 0; j < 5; j++)
        {
             
            // Pass only those values which
            // are non - zero
            if (sparseMatrix[i][j] != 0)
                create_new_node(&first, i, j,
                                sparseMatrix[i][j]);
        }
    }
    printList(first);
 
    return 0;
}
 
// This code is contributed by ronaksuba


C




// C program for Sparse Matrix Representation
// using Linked Lists
#include<stdio.h>
#include<stdlib.h>
 
// Node to represent sparse matrix
struct Node
{
    int value;
    int row_position;
    int column_postion;
    struct Node *next;
};
 
// Function to create new node
void create_new_node(struct Node** start, int non_zero_element,
                     int row_index, int column_index )
{
    struct Node *temp, *r;
    temp = *start;
    if (temp == NULL)
    {
        // Create new node dynamically
        temp = (struct Node *) malloc (sizeof(struct Node));
        temp->value = non_zero_element;
        temp->row_position = row_index;
        temp->column_postion = column_index;
        temp->next = NULL;
        *start = temp;
 
    }
    else
    {
        while (temp->next != NULL)
            temp = temp->next;
 
        // Create new node dynamically
        r = (struct Node *) malloc (sizeof(struct Node));
        r->value = non_zero_element;
        r->row_position = row_index;
        r->column_postion = column_index;
        r->next = NULL;
        temp->next = r;
 
    }
}
 
// This function prints contents of linked list
// starting from start
void PrintList(struct Node* start)
{
    struct Node *temp, *r, *s;
    temp = r = s = start;
 
    printf("row_position: ");
    while(temp != NULL)
    {
 
        printf("%d ", temp->row_position);
        temp = temp->next;
    }
    printf("\n");
 
    printf("column_postion: ");
    while(r != NULL)
    {
        printf("%d ", r->column_postion);
        r = r->next;
    }
    printf("\n");
    printf("Value: ");
    while(s != NULL)
    {
        printf("%d ", s->value);
        s = s->next;
    }
    printf("\n");
}
 
 
// Driver of the program
int main()
{
   // Assume 4x5 sparse matrix
    int sparseMatric[4][5] =
    {
        {0 , 0 , 3 , 0 , 4 },
        {0 , 0 , 5 , 7 , 0 },
        {0 , 0 , 0 , 0 , 0 },
        {0 , 2 , 6 , 0 , 0 }
    };
 
    /* Start with the empty list */
    struct Node* start = NULL;
 
    for (int i = 0; i < 4; i++)
        for (int j = 0; j < 5; j++)
 
            // Pass only those values which are non - zero
            if (sparseMatric[i][j] != 0)
                create_new_node(&start, sparseMatric[i][j], i, j);
 
    PrintList(start);
 
    return 0;
}


Java




// Java program for sparse matrix representation.
// Using Link list
import java.util.*;
 
public class SparseMatrix {
    // Creating head/first node of list as NULL
    static Node first = null;
 
    // Node class to represent link list
    public static class Node {
        int row;
        int col;
        int data;
        Node next;
    };
 
    // Driver Code
    public static void main(String[] args)
    {
        // 4x5 sparse matrix
        int[][] sparseMatrix = { { 0, 0, 3, 0, 4 },
                                 { 0, 0, 5, 7, 0 },
                                 { 0, 0, 0, 0, 0 },
                                 { 0, 2, 6, 0, 0 } };
 
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 5; j++) {
                // Pass only those values which
                // are non - zero
                if (sparseMatrix[i][j] != 0) {
                    create_new_node(i, j,
                                    sparseMatrix[i][j]);
                }
            }
        }
        printList(first);
    }
    // Function to create new node
    private static void
    create_new_node(int row_index, int col_index, int x)
    {
        Node temp = first;
        Node r;
 
        // If link list is empty then
        // create first node and assign value.
        if (temp == null) {
            temp = new Node();
            temp.row = row_index;
            temp.col = col_index;
            temp.data = x;
            temp.next = null;
            first = temp;
        }
 
        // If link list is already created
        // then append newly created node
        else {
            while (temp.next != null)
                temp = temp.next;
 
            r = new Node();
            r.row = row_index;
            r.col = col_index;
            r.data = x;
            r.next = null;
            temp.next = r;
        }
    }
 
    // Function prints contents of linked list
    // starting from start
    public static void printList(Node start)
    {
        Node ptr = start;
        System.out.print("row_position:");
        while (ptr != null) {
            System.out.print(ptr.row + " ");
            ptr = ptr.next;
        }
        System.out.println("");
        System.out.print("column_position:");
 
        ptr = start;
        while (ptr != null) {
            System.out.print(ptr.col + " ");
            ptr = ptr.next;
        }
        System.out.println("");
        System.out.print("Value:");
        ptr = start;
 
        while (ptr != null) {
            System.out.print(ptr.data + " ");
            ptr = ptr.next;
        }
    }
}
 
// This code is contributed by Tapesh (tapeshdua420)


Python3




# Python Program for Representation of
# Sparse Matrix using Linked List
 
# Node Class to represent Linked List Node
class Node:
 
    # Making the slots for storing row,
    # column, value, and address
    __slots__ = "row", "col", "data", "next"
 
    # Constructor to initialize the values
    def __init__(self, row=0, col=0, data=0, next=None):
 
        self.row = row
        self.col = col
        self.data = data
        self.next = next
 
 
# Class to convert Sparse Matrix
# into Linked List
class Sparse:
 
    # Initialize Class Variables
    def __init__(self):
        self.head = None
        self.temp = None
        self.size = 0
 
    # Function which returns the size
    # of the Linked List
    def __len__(self):
        return self.size
 
    # Check the Linked List is
    # Empty or not
    def isempty(self):
        return self.size == 0
 
    # Responsible function to create
    # Linked List from Sparse Matrix
    def create_new_node(self, row, col, data):
 
        # Creating New Node
        newNode = Node(row, col, data, None)
 
        # Check whether the List is
        # empty or not
        if self.isempty():
            self.head = newNode
        else:
            self.temp.next = newNode
        self.temp = newNode
 
        # Incrementing the size
        self.size += 1
 
    # Function display the contents of
    # Linked List
    def PrintList(self):
        temp = r = s = self.head
        print("row_position:", end=" ")
        while temp != None:
            print(temp.row, end=" ")
            temp = temp.next
        print()
        print("column_postion:", end=" ")
        while r != None:
            print(r.col, end=" ")
            r = r.next
        print()
        print("Value:", end=" ")
        while s != None:
            print(s.data, end=" ")
            s = s.next
        print()
 
# Driver Code
if __name__ == "__main__":
 
    # Creating Object
    s = Sparse()
 
    # Assuming 4x5 Sparse Matrix
    sparseMatric = [[0, 0, 3, 0, 4],
                    [0, 0, 5, 7, 0],
                    [0, 0, 0, 0, 0],
                    [0, 2, 6, 0, 0]]
    for i in range(4):
        for j in range(5):
 
            # Creating Linked List by only those
            # elements which are non-zero
            if sparseMatric[i][j] != 0:
                s.create_new_node(i, j, sparseMatric[i][j])
 
    # Printing the Linked List Representation
    # of the sparse matrix
    s.PrintList()
 
    # This code is contributed by Naveen Rathore


C#




// C# program for sparse matrix representation.
// Using Link list
using System;
 
class Program
{
   
    // Creating head/first node of list as NULL
    static Node first = null;
 
    // Node class to represent link list
    public class Node {
        public int row;
        public int col;
        public int data;
        public Node next;
    };
 
    // Driver Code
    static void Main(string[] args)
    {
        // 4x5 sparse matrix
        int[, ] sparseMatrix = { { 0, 0, 3, 0, 4 },
                                 { 0, 0, 5, 7, 0 },
                                 { 0, 0, 0, 0, 0 },
                                 { 0, 2, 6, 0, 0 } };
 
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 5; j++) {
                // Pass only those values which
                // are non - zero
                if (sparseMatrix[i, j] != 0) {
                    create_new_node(i, j,
                                    sparseMatrix[i, j]);
                }
            }
        }
        printList(first);
    }
 
    // Function to create new node
    private static void
    create_new_node(int row_index, int col_index, int x)
    {
        Node temp = first;
        Node r;
 
        // If link list is empty then
        // create first node and assign value.
        if (temp == null) {
            temp = new Node();
            temp.row = row_index;
            temp.col = col_index;
            temp.data = x;
            temp.next = null;
            first = temp;
        }
 
        // If link list is already created
        // then append newly created node
        else
 
        {
            while (temp.next != null)
                temp = temp.next;
 
            r = new Node();
            r.row = row_index;
            r.col = col_index;
            r.data = x;
            r.next = null;
            temp.next = r;
        }
    }
 
    // Function prints contents of linked list
    // starting from start
    public static void printList(Node start)
    {
        Node ptr = start;
        Console.Write("row_position:");
        while (ptr != null) {
            Console.Write(ptr.row + " ");
            ptr = ptr.next;
        }
        Console.WriteLine("");
        Console.Write("column_position:");
        ptr = start;
        while (ptr != null) {
            Console.Write(ptr.col + " ");
            ptr = ptr.next;
        }
        Console.WriteLine("");
        Console.Write("Value:");
        ptr = start;
        while (ptr != null) {
            Console.Write(ptr.data + " ");
            ptr = ptr.next;
        }
    }
}
 
// This code is contributed by Tapesh (tapeshdua420)


Javascript




// JS Program for Representation of
// Sparse Matrix into Linked List
 
// Node Class to represent Linked List Node
class Node
{
    constructor(row, col, data)
    {
        this.row = row;
        this.col = col;
        this.data = data;
        this.next = null;
    }
}
 
// Class to convert Sparse Matrix
// into Linked List
class Sparse
{
 
    // Initialize Class Variables
    constructor()
    {
        this.head = null
        this.temp = null
        this.size = 0
    }
 
    // Function which returns the size
    // of the Linked List
    len()
    {
        return this.size
    }
 
    // Check the Linked List is
    // Empty or not
    isempty()
    {
        return this.size == 0
    }
 
    // Responsible function to create
    // Linked List from Sparse Matrix
    create_new_node(row, col, data)
    {
        // Creating New Node
        let newNode = new Node(row, col, data)
 
        // Check whether the List is
        // empty or not
        if (this.isempty())
            this.head = newNode
        else
            (this.temp).next = newNode
        this.temp = newNode
 
        // Incrementing the size
        this.size += 1
    }
 
    // Function display the contents of
    // Linked List
    PrintList()
    {
        let temp = this.head
        let r = this.head
        let s = this.head
         
        process.stdout.write("row_position: ")
        while (temp != null)
        {
            process.stdout.write(temp.row + " ")
            temp = temp.next
        }
        console.log()
        process.stdout.write("column_postion: ")
        while (r != null)
        {
            process.stdout.write(r.col + " " )
            r = r.next
        }
        console.log()
        process.stdout.write("Value: ")
        while (s != null)
        {
            process.stdout.write(s.data + " ")
            s = s.next
        }
        console.log()
    }
}
 
// Driver Code
 
// Creating Object
let s = new Sparse()
 
// Assuming 4x5 Sparse Matrix
let sparseMatric = [[0, 0, 3, 0, 4],
                    [0, 0, 5, 7, 0],
                    [0, 0, 0, 0, 0],
                    [0, 2, 6, 0, 0]]
 
for (var i = 0; i < 4; i++)
    for (var j = 0; j < 5; j++)
        // Creating Linked List by only those
        // elements which are non-zero
        if (sparseMatric[i][j] != 0)
        {
            s.create_new_node(i, j, sparseMatric[i][j])
            s.data = sparseMatric[i][j]
        }
             
 
 
             
 
// Printing the Linked List Representation
// of the sparse matrix
s.PrintList()


Output

row_position:0 0 1 1 3 3 
column_position:2 4 2 3 1 2 
Value:3 4 5 7 2 6 

Time Complexity:  O(N*M), where N is the number of rows in the sparse matrix, and M is the number of columns in the sparse matrix.
Auxiliary Space: O(K), where K is the number of non-zero elements in the array.

Other representations: 

As a Dictionary where row and column numbers are used as keys and values are matrix entries. This method saves space but sequential access of items is costly.

As a list of list. The idea is to make a list of rows and every item of list contains values. We can keep list items sorted by column numbers.
Sparse Matrix and its representations | Set 2 (Using List of Lists and Dictionary of keys)



Last Updated : 12 Sep, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads