A matrix is a rectangular arrangement of elements in rows and columns. In programming, it is implemented as a 2-D array, where each element is accessed using two indices [row][column].
Declaration & Initialization:
Built-in Functions:
Traversing a Matrix:
Traversing a Matrix (2-D array) means visiting every element using nested loops. Since a matrix has rows and columns, traversal requires:
- Outer loop - iterate through rows
- Inner loop - iterate through columns
- Time Complexity: O(m × n)
#include <bits/stdc++.h>
using namespace std;
void traverserowwise(vector<vector<int>>& matrix, int n, int m) {
// row wise traversal
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++) {
cout << matrix[i][j] << " ";
}
cout << endl;
}
}
void traversecolumnwise(vector<vector<int>>& matrix, int n, int m) {
// column wise traversal
for(int j = 0; j < m; j++) {
for(int i = 0; i < n; i++) {
cout << matrix[i][j] << " ";
}
cout << endl;
}
}
int main() {
int n = 2, m = 3;
vector<vector<int>> matrix = {{1,2,3}, {4,5,6}};
traverserowwise(matrix, n, m);
cout << endl;
traversecolumnwise(matrix, n, m);
return 0;
}
import java.util.*;
class GfG {
public void traverserowwise(int[][] matrix, int n, int m) {
// row wise traversal
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
}
public void traversecolumnwise(int[][] matrix, int n, int m) {
// column wise traversal
for(int j = 0; j < m; j++) {
for(int i = 0; i < n; i++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
}
}
class main {
public static void main(String[] args) {
int n = 2, m = 3;
int[][] matrix = {{1,2,3},{4,5,6}};
GfG obj = new GfG();
obj.traverserowwise(matrix, n, m);
System.out.println();
obj.traversecolumnwise(matrix, n, m);
}
}
def traverserowwise(matrix, n, m):
# row wise traversal
for i in range(n):
for j in range(m):
print(matrix[i][j], end=" ")
print()
def traversecolumnwise(matrix, n, m):
# column wise traversal
for j in range(m):
for i in range(n):
print(matrix[i][j], end=" ")
print()
def main():
n = 2
m = 3
matrix = [[1,2,3],[4,5,6]]
traverserowwise(matrix, n, m)
print()
traversecolumnwise(matrix, n, m)
if __name__ == "__main__":
main()
using System;
class GfG {
public void traverserowwise(int[,] matrix, int n, int m) {
// row wise traversal
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++) {
Console.Write(matrix[i,j] + " ");
}
Console.WriteLine();
}
}
public void traversecolumnwise(int[,] matrix, int n, int m) {
// column wise traversal
for(int j = 0; j < m; j++) {
for(int i = 0; i < n; i++) {
Console.Write(matrix[i,j] + " ");
}
Console.WriteLine();
}
}
}
class main {
static void Main() {
int n = 2;
int m = 3;
int[,] matrix = { {1,2,3},{4,5,6} };
GfG obj = new GfG();
obj.traverserowwise(matrix, n, m);
Console.WriteLine();
obj.traversecolumnwise(matrix, n, m);
}
}
function traverserowwise(matrix, n, m) {
// row-wise traversal
for (let i = 0; i < n; i++) {
let row = "";
for (let j = 0; j < m; j++) {
row += matrix[i][j] + " ";
}
console.log(row.trim());
}
}
function traversecolumnwise(matrix, n, m) {
// column-wise traversal
for (let j = 0; j < m; j++) {
let col = "";
for (let i = 0; i < n; i++) {
col += matrix[i][j] + " ";
}
console.log(col.trim());
}
}
// driver code
let n = 2;
let m = 3;
let matrix = [[1, 2, 3], [4, 5, 6]];
traverserowwise(matrix, n, m);
console.log();
traversecolumnwise(matrix, n, m);
Output
1 2 3 4 5 6 1 4 2 5 3 6
Classical Algorithm and Problem on 2D-Arrays:
1. Matrix Multiplication
Matrix multiplication is a classical matrix problem where each element of the resulting matrix is calculated as the dot product of a row from the first matrix and a column from the second. It combines two matrices to form a new one based on this rule.
Core Idea: For C[i][j], sum the product of corresponding elements from row i of matrix A and column j of matrix B:
C[i][j] = A[i][0]*B[0][j] + A[i][1]*B[1][j] + ... + A[i][k]*B[k][j]
vector<vector<int>> mult(vector<vector<int>>& arr, vector<vector<int>>& brr) {
int n = arr.size();
// to store the resultant matrix
vector<vector<int>> res(n, vector<int>(n, 0));
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
for(int k = 0; k < n; k++) {
res[i][j] += arr[i][k] * brr[k][j];
}
}
}
return res;
}
int[][] multiply(int[][] arr, int[][] brr){
int n = arr.length;
// to store the resultant matrix
int[][] res = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
res[i][j] += arr[i][k] * brr[k][j];
}
}
}
return res;
}
def multiply(arr, brr):
n = len(arr)
# to store the resultant matrix
res = [[0 for _ in range(n)] for _ in range(n)]
for i in range(n):
for j in range(n):
for k in range(n):
res[i][j] += arr[i][k] * brr[k][j]
return res
List<List<int> > multiply(List<List<int> > arr,
List<List<int> > brr){
int n = arr.Count;
// to store the resultant matrix
List<List<int> > res = new List<List<int> >();
for (int i = 0; i < n; i++) {
List<int> row = new List<int>();
for (int j = 0; j < n; j++) {
row.Add(0);
}
res.Add(row);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
res[i][j] += arr[i][k] * brr[k][j];
}
}
}
return res;
}
function multiply(arr, brr) {
let n = arr.length;
// to store the resultant matrix
let res = new Array(n);
for (let i = 0; i < n; i++) {
res[i] = new Array(n).fill(0);
}
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
for (let k = 0; k < n; k++) {
res[i][j] += arr[i][k] * brr[k][j];
}
}
}
return res;
}
2. Rotate Square Matrix by 90 Degrees
Rotate Square Matrix by 90 Degrees is a classical problem where a square 2D matrix is rotated 90 degrees clockwise. In this transformation, the first row becomes the last column, the second row becomes the second-last column, and so on.
function rotateMatrix(mat) {
const n = mat.length;
// Consider all cycles one by one
for (let i = 0; i < n / 2; i++) {
// Consider elements in group of 4
// as P1, P2, P3 & P4 in current square
for (let j = i; j < n - i - 1; j++) {
let temp = mat[i][j];
mat[i][j] = mat[j][n - 1 - i];
mat[j][n - 1 - i] = mat[n - 1 - i][n - 1 - j];
mat[n - 1 - i][n - 1 - j] = mat[n - 1 - j][i];
mat[n - 1 - j][i] = temp;
}
}
}
void rotateMatrix(int[][] mat)
{
int n = mat.length;
// Consider all cycles one by one
for (int i = 0; i < n / 2; i++) {
// Consider elements in group of 4
// as P1, P2, P3 & P4 in current square
for (int j = i; j < n - i - 1; j++) {
int temp = mat[i][j];
mat[i][j] = mat[j][n - 1 - i];
mat[j][n - 1 - i] = mat[n - 1 - i][n - 1 - j];
mat[n - 1 - i][n - 1 - j] = mat[n - 1 - j][i];
mat[n - 1 - j][i] = temp;
}
}
}
def rotateMatrix(mat):
n = len(mat)
# Consider all cycles one by one
for i in range(n // 2):
# Consider elements in group of 4
# as P1, P2, P3 & P4 in current square
for j in range(i, n - i - 1):
temp = mat[i][j]
mat[i][j] = mat[j][n - 1 - i]
mat[j][n - 1 - i] = mat[n - 1 - i][n - 1 - j]
mat[n - 1 - i][n - 1 - j] = mat[n - 1 - j][i]
mat[n - 1 - j][i] = temp
void rotateMatrix(int[][] mat)
{
int n = mat.Length;
// Consider all cycles one by one
for (int i = 0; i < n / 2; i++) {
// Consider elements in group of 4
// as P1, P2, P3 & P4 in current square
for (int j = i; j < n - i - 1; j++) {
int temp = mat[i][j];
mat[i][j] = mat[j][n - 1 - i];
mat[j][n - 1 - i] = mat[n - 1 - i][n - 1 - j];
mat[n - 1 - i][n - 1 - j] = mat[n - 1 - j][i];
mat[n - 1 - j][i] = temp;
}
}
function rotateMatrix(mat)
{
const n = mat.length;
// Consider all cycles one by one
for (let i = 0; i < n / 2; i++) {
// Consider elements in group of 4
// as P1, P2, P3 & P4 in current square
for (let j = i; j < n - i - 1; j++) {
let temp = mat[i][j];
mat[i][j] = mat[j][n - 1 - i];
mat[j][n - 1 - i] = mat[n - 1 - i][n - 1 - j];
mat[n - 1 - i][n - 1 - j] = mat[n - 1 - j][i];
mat[n - 1 - j][i] = temp;
}
}
}
3. Transpose of a Matrix
Transpose of a matrix is a classical matrix problem that involves flipping the matrix over its main diagonal, converting rows into columns. The element at matrix[i][j] is moved to matrix[j][i].
Core Idea: Swap elements matrix[i][j] and matrix[j][i] for all i < j to flip the matrix over its main diagonal without using extra space.
function transpose(mat)
{
const rows = mat.length;
const cols = mat[0].length;
// Create a result matrix of size
// cols x rows for the transpose
const tMat = new Array(cols).fill(0).map(() = > new Array(rows).fill(0));
// Fill the transposed matrix by
// swapping rows with columns
for (let i = 0; i < rows; i++)
{
for (let j = 0; j < cols; j++)
{
// Assign transposed value
tMat[j][i] = mat[i][j];
}
}
return tMat;
}
ArrayList<ArrayList<Integer> > transpose(int[][] mat)
{
int rows = mat.length;
int cols = mat[0].length;
// Create a result matrix of size
// cols x rows for the transpose
ArrayList<ArrayList<Integer> > tMat = new ArrayList<>();
// Fill the transposed matrix by
// swapping rows with columns
for (int i = 0; i < cols; i++) {
ArrayList<Integer> row = new ArrayList<>();
for (int j = 0; j < rows; j++) {
// Assign transposed value
row.add(mat[j][i]);
}
tMat.add(row);
}
return tMat;
}
def transpose(mat):
rows = len(mat)
cols = len(mat[0])
# Create a result matrix of size
# cols x rows for the transpose
tMat = [[0 for _ in range(rows)] for _ in range(cols)]
# Fill the transposed matrix by
# swapping rows with columns
for i in range(rows):
for j in range(cols):
# Assign transposed value
tMat[j][i] = mat[i][j]
return tMat
List<List<int> > transpose(int[, ] mat)
{
int rows = mat.GetLength(0);
int cols = mat.GetLength(1);
// Create a result matrix of size
// cols x rows for the transpose
List<List<int> > tMat = new List<List<int> >();
// Fill the transposed matrix by
// swapping rows with columns
for (int j = 0; j < cols; j++) {
List<int> row = new List<int>();
for (int i = 0; i < rows; i++) {
// Assign transposed value
row.Add(mat[i, j]);
}
tMat.Add(row);
}
return tMat;
}
function transpose(mat)
{
const rows = mat.length;
const cols = mat[0].length;
// Create a result matrix of size
// cols x rows for the transpose
const tMat = new Array(cols).fill(0).map(
() => new Array(rows).fill(0));
// Fill the transposed matrix by
// swapping rows with columns
for (let i = 0; i < rows; i++) {
for (let j = 0; j < cols; j++) {
// Assign transposed value
tMat[j][i] = mat[i][j];
}
}
return tMat;
}
4. Spiral Traversal
Spiral traversal is the classical matrix problem where elements are accessed in a spiral order starting from the top-left corner.The traversal moves right → down → left → up layer by layer until all elements are visited.
Core Idea: Traverse the matrix layer by layer, adjusting boundaries to follow a directional pattern, ensuring no element is visited twice.
vector<int> spirallyTraverse(vector<vector<int>> &mat)
{
int m = mat.size();
int n = mat[0].size();
vector<int> res;
// Initialize boundaries
int top = 0, bottom = m - 1, left = 0, right = n - 1;
// Iterate until all elements are Stored
while (top <= bottom && left <= right)
{
// Store top row from left to right
for (int i = left; i <= right; ++i)
{
res.push_back(mat[top][i]);
}
top++;
// Store right column from top to bottom
for (int i = top; i <= bottom; ++i)
{
res.push_back(mat[i][right]);
}
right--;
// Store bottom row from right to left (if exists)
if (top <= bottom)
{
for (int i = right; i >= left; --i)
{
res.push_back(mat[bottom][i]);
}
bottom--;
}
// Store left column from bottom to top (if exists)
if (left <= right)
{
for (int i = bottom; i >= top; --i)
{
res.push_back(mat[i][left]);
}
left++;
}
}
return res;
}
ArrayList<Integer> spirallyTraverse(int[][] mat)
{
int m = mat.length;
int n = mat[0].length;
ArrayList<Integer> res = new ArrayList<>();
// Initialize boundaries
int top = 0, bottom = m - 1, left = 0, right = n - 1;
// Iterate until all elements are Stored
while (top <= bottom && left <= right) {
// Store top row from left to right
for (int i = left; i <= right; ++i) {
res.add(mat[top][i]);
}
top++;
// Store right column from top to bottom
for (int i = top; i <= bottom; ++i) {
res.add(mat[i][right]);
}
right--;
// Store bottom row from right to left (if exists)
if (top <= bottom) {
for (int i = right; i >= left; --i) {
res.add(mat[bottom][i]);
}
bottom--;
}
// Store left column from bottom to top (if exists)
if (left <= right) {
for (int i = bottom; i >= top; --i) {
res.add(mat[i][left]);
}
left++;
}
}
return res;
}
def spirallyTraverse(mat):
m, n = len(mat), len(mat[0])
res = []
# Initialize boundaries
top, bottom, left, right = 0, m - 1, 0, n - 1
# Iterate until all elements are Stored
while top <= bottom and left <= right:Store
# Store top row from left to right
for i in range(left, right + 1):
res.append(mat[top][i])
top += 1
# Store right column from top to bottom
for i in range(top, bottom + 1):
res.append(mat[i][right])
right -= 1
# Store bottom row from right to left (if exists)
if top <= bottom:
for i in range(right, left - 1, -1):
res.append(mat[bottom][i])
bottom -= 1
# Store left column from bottom to top (if exists)
if left <= right:
for i in range(bottom, top - 1, -1):
res.append(mat[i][left])
left += 1
return res
List<int> spirallyTraverse(int[, ] mat)
{
int m = mat.GetLength(0);
int n = mat.GetLength(1);
List<int> res = new List<int>();
// Initialize boundaries
int top = 0, bottom = m - 1, left = 0, right = n - 1;
// Iterate until all elements are Stored
while (top <= bottom && left <= right) {
// Store top row from left to right
for (int i = left; i <= right; ++i) {
res.Add(mat[top, i]);
}
top++;
// Store right column from top to bottom
for (int i = top; i <= bottom; ++i) {
res.Add(mat[i, right]);
}
right--;
// Store bottom row from right to left (if exists)
if (top <= bottom) {
for (int i = right; i >= left; --i) {
res.Add(mat[bottom, i]);
}
bottom--;
}
// Store left column from bottom to top (if exists)
if (left <= right) {
for (int i = bottom; i >= top; --i) {
res.Add(mat[i, left]);
}
left++;
}
}
return res;
}
function spirallyTraverse(mat)
{
const m = mat.length;
const n = mat[0].length;
const res = [];
// Initialize boundaries
let top = 0, bottom = m - 1, left = 0, right = n - 1;
// Iterate until all elements are Stored
while (top <= bottom && left <= right) {
// Store top row from left to right
for (let i = left; i <= right; ++i) {
res.push(mat[top][i]);
}
top++;
// Store right column from top to bottom
for (let i = top; i <= bottom; ++i) {
res.push(mat[i][right]);
}
right--;
// Store bottom row from right to left (if exists)
if (top <= bottom) {
for (let i = right; i >= left; --i) {
res.push(mat[bottom][i]);
}
bottom--;
}
// Store left column from bottom to top (if exists)
if (left <= right) {
for (let i = bottom; i >= top; --i) {
res.push(mat[i][left]);
}
left++;
}
}
return res;
}
