JavaScript program to find the maximum and minimum values ​​in a square matrix

To find the largest or smallest element, we must focus on the number of comparisons to be made and which method of comparison is chosen to be most efficient: the method of comparing elements using an if-else statement or using an if- The else statement compares elements as a built-in method. We will see the complete code implementation and explanation. In this article, we will implement a JavaScript program that calculates the largest and smallest elements present in a given square matrix.

Problem Introduction

This question is simple, but delving deeper will bring up some outstanding concepts worth learning.

In this problem we are given a matrix for which we have to find the maximum and minimum element present in it. For example, if the matrix is ​​-

Mat = [ 1, 3, 7,
   5, 2, 9, 
   2, 5, 1]

From the above matrix, we can say that 1 is the minimum or minimum element and 9 is the maximum or maximum element.

Let us see how to solve this problem through code implementation -

Naive method

In this method we will simply iterate through all elements at once and check if they are larger than our current element. The following steps will be followed -

• First, we will create a function to pass different matrices and get the results

• For a given matrix, we will get its rows and columns in order to iterate over it using a for loop.

• We will create two variables to store the minimum and maximum elements and assume that the elements of the matrix are less than or equal to this value and initialize them to the minimum element 1000000000.

• Additionally, we will initialize the maximum element to -1000000000 assuming the elements of the matrix are greater than or equal to this value.

• Using a for loop, we will iterate through the matrix and for each index we will use two if-else conditions.

• We will update the maximum and minimum values ​​by making the required comparisons.

Example

// creating a function to get the minimum and maximum number
function min_max(matrix){

   // getting rows and columns of given matrix
   var rows = matrix.length
   var cols = matrix[0].length
   var min_ans = 1000000000
   var max_ans = -1000000000
   
   // traversing over the matrix
   for(var i = 0; i<rows; i++){
      for(var j = 0; j<cols; j++){
         if(min_ans > matrix[i][j]){
            min_ans = matrix[i][j];
         }
         if(max_ans < matrix[i][j]) {
            max_ans = matrix[i][j];
         }
      }
   }
   console.log("The maximum element present in the Matrix is: " + max_ans);
   console.log("The minimum element present in the Matrix is: " + min_ans);
}

// defining the matrix
Mat = [ [1, 3, 7],
[5, 2, 9],
[2, 5, 1] ]

// calling the function
min_max(Mat)

Time and space complexity

The time complexity of the above code is O(N*M), where N and M are rows and columns respectively. In addition, the space complexity is O(1).

The main issue here is not the time complexity, but the number of comparisons we make. In the above code, we are doing N * M * 2 comparisons because for each index we are checking the minimum and maximum elements.

More effective methods

This method is similar to the above method in most parts, but for the comparison part, we will now do a 3/2 * N* M comparison by updating some if-else statements. Let's look at the code -

Example

// creating a function to get the minimum and maximum number
function min_max(matrix){

   // getting rows and columns of given matrix
   var rows = matrix.length
   var cols = matrix[0].length
   var min_ans = 1000000000
   var max_ans = -1000000000
   
   // traversing over the matrix
   for(var i = 0; i<rows; i++){
      for(var j = 0; j<=cols/2; j++){
         if (matrix[i][j] > matrix[i][rows - j - 1]){
            if (min_ans > matrix[i][cols - j - 1])
            min_ans = matrix[i][cols - j - 1];
            if (max_ans< matrix[i][j])
            max_ans = matrix[i][j];
         } else {
            if (min_ans > matrix[i][j])
            min_ans = matrix[i][j];
            if (max_ans < matrix[i][cols - j - 1])
            max_ans = matrix[i][cols - j - 1];
         }
      }
   }
   console.log("The maximum element present in the Matrix is: " + max_ans);
   console.log("The minimum element present in the Matrix is: " + min_ans);
}
// defining the matrix
Mat = [ [1, 3, 7],
[5, 2, 9],
[2, 5, 1] ]
// calling the function
min_max(Mat)

Time and space complexity

The time complexity of the above code is O(N*M), where N and M are rows and columns respectively. In addition, the space complexity is O(1).

The number of comparisons here is less than before, now 3/2 * (N*M).

in conclusion

In this tutorial, we will implement a JavaScript program that calculates the largest and smallest elements present in a given square matrix. We iterate over the given matrix and compare each element with the variable storing the answer. Two techniques are discussed: one with 2*N*M comparisons and the other with 3/2*N*M comparisons, but both methods have the same space complexity.

The above is the detailed content of JavaScript program to find the maximum and minimum values ​​in a square matrix. For more information, please follow other related articles on the PHP Chinese website!