The best programs are written so that computing machines can perform them quickly and so that human beings can understand them clearly. A programmer is ideally an essayist who works with traditional aesthetic and literary forms as
well as mathematical concepts, to communicate the way that an algorithm works and to convince a reader that the results will be correct. Donald E. Knuth

Two Dimensional Arrays

Introduction to 2D Arrays ( Matrix )
So, far we have seen one dimensional arrays. Now we will see two dimensional array also known as matrix, which is another useful data structure. Consider the declaration below :

int mat [ 3 ][ 4 ];

We have declared a two dimensional array or matrix with 3 rows and 4 columns. We can store 3 x 4 = 12 elements in this matrix. Each element is stored in a cell which can be accessed using the combination of
row index and column index. Initialization of a 2D array is shown below :

InitializationIndexing
int mat[3][4] = { { 17, 23, 15, 19 },
                  { 44, 29, 52, 76 },
                  { 21, 63, 35, 57 } };

17 [ 0, 0 ]23 [ 0, 1 ]15 [ 0, 2 ]19 [ 0, 3 ]
44 [ 1, 0 ]29 [ 1, 1 ]52 [ 1, 2 ]76 [ 1, 3 ]
21 [ 2, 0 ]63 [ 2, 1 ]35 [ 2, 2 ]57 [ 2, 3 ]

We can see how the above initialization statement in the left builds a matrix shown in the right. Every element is stored in a cell which has a index shown as subscript of each element. For e.g, 52 is stored in a cell with index
[ 1, 2 ] where 1 denotes the row number ( index ) and 2 denotes the column number ( index ). Please note that both row and column index starts with 0.
Following program inputs a matrix from user and displays it :

#include<iostream>
using namespace std;

int main() {
   int mat[3][3]; // matrix can have max 3 rows and 3 cols
   int i, j;
   cout << "Enter the matrix elements row-wise :- " << endl;
   for ( i = 0; i < 3; i++ ) { // outer loop iterates over each row
      for ( j = 0; j < 3; j++ ) { // inter loop iterates over each column
         cout << "mat[" << i << "][" << j << "] : ";
         // i -> row no. and j -> col no.
         cin >> mat[i][j];
      }
   }
   // display the matrix
   cout << "You have entered the matrix :- " << endl;
   for ( i = 0; i < 3; i++ ) {
      for ( j = 0; j < 3; j++ ) {
         cout << mat[i][j] << " ";
      }
      cout << endl;
   }
   return 0;
}
Run this program in your system to take input at run-time  


Passing 2D Array to Function
2D Arrays (matrices) are passed similar to 1D arrays but the no. of columns must be specified in the argument of the function to which a matrix has been passed. In the following program we implement four functions which takes a matrix as an argument and perform the following functions :
1) Compute sum of left diagonal elements
2) Compute sum of right diagonal elements
3) Print the lower diagonal matrix
4) Print the upper diagonal matrix

/* 
 * This program does the following operations on a matrix 
 * 1) Calculate the sum of left and right diagonal matrix
 * 2) Print the lower and upper diagonal elements
 * For the matrix :  2 3 8 4
                     5 1 7 3
           	     9 2 6 8
           	     1 4 5 7
 * Sum of left diagonal elements = 2 + 1 + 6 + 7 = 16
 * Sum of right diagonal elements = 4 + 7 + 2 + 1 = 14
 * Lower diagonal matrix ( all elements below left diagonal ) : 
   5
   9 2
   1 4 5
 * Upper diagonal matrix ( all elements   above left diagonal ) : 
   3 8 4
     7 3
       8                               
*/

#include<iostream>
using namespace std;

/* computes the sum of left diagonal elements */
int sumLeftDiagElements(int mat[][4], int rows, int cols) {
   int i, j, sum = 0;
   for ( i = 0; i < rows; i++ ) {
      for ( j = 0; j < cols; j++ ) {
         if ( i == j ) { // we found a left diagonal element
            sum += mat[i][j];
         }
      }
   }
   return sum;
}

/* computes the sum of right diagonal elements */
int sumRightDiagElements(int mat[][4], int rows, int cols) {
   int i, j, sum = 0;
   for ( i = 0; i < rows; i++ ) {
      for ( j = 0; j < cols; j++ ) {
         if ( (i + j) == (rows - 1) ) { // we found a right diagonal element
            sum += mat[i][j];
         }
      }
   }
   return sum;
}

/* Print the lower diagonal elements */
void lowerDiagMatrix(int mat[][4], int rows, int cols) {
   int i, j;
   for ( i = 0; i < rows; i++ ) {
      for ( j = 0; j < cols; j++ ) {
         if ( i > j ) { // we found a lower diagonal element
            cout << mat[i][j] << " ";
         }
      }
      cout << endl;
   }
}

/* Print the upper diagonal elements */
void upperDiagMatrix(int mat[][4], int rows, int cols) {
   int i, j;
   for ( i = 0; i < rows; i++ ) {
      for ( j = 0; j < cols; j++ ) {
         if ( i < j ) { // we found a upper diagonal element
            cout << mat[i][j] << " ";
         }
         else {
            cout << "  ";
         }
      }
      cout << endl;
   }
}

int main() {
   int mat[4][4] = { { 2, 3, 8, 4 },
           	     	 { 5, 1, 7, 3 },
           	     	 { 9, 2, 6, 8 },
           	     	 { 1, 4, 5, 7 } };
   int left_diag_sum = sumLeftDiagElements(mat, 4, 4);
   cout << "Sum of Left Diagonal elements : " << left_diag_sum << endl;
   int right_diag_sum = sumRightDiagElements(mat, 4, 4);
   cout << "Sum of Right Diagonal elements : " << right_diag_sum << endl;
   cout << "Lower Diagonal Elements :- ";
   lowerDiagMatrix(mat, 4, 4);
   cout << "Upper Diagonal Elements :- " << endl;
   upperDiagMatrix(mat, 4, 4);
   return 0;
}


Dynamic memory allocation for Two Dimensional Arrays
Similar to 1D arrays, 2D arrays are dynamically allocated and deallocated using new and delete operator.
See the program below :

#include<iostream>
using namespace std;

int main() {
   int **mat, rows = 3, cols = 3, i, j;
   // dynamically allocate memory for a matrix of size m x n
   mat = new int*[rows];
   for ( i = 0; i < rows; i++ ) {
      mat[i] = new int[cols];
   }
   // initialize matrix elements
   for ( i = 0; i < rows; i++ ) {
      for ( j = 0; j < cols; j++ ) {
         mat[i][j] = i + j;         
      }
   }
   // display matrix 
   for ( i = 0; i < rows; i++ ) {
      for ( j = 0; j < cols; j++ ) {
         cout << mat[i][j] << " ";
      }
      cout << endl;
   }
   // deallocate (free) the memory
   for ( i = 0; i < rows; i++ ) {
      delete mat[i];
   }
   delete mat;
   return 0;
}

Back | Next