Interchange Diagonals of a Matrix in Java

In this article, we will understand how to interchange the diagonals in Java. A matrix has a row-and-column arrangement of its elements. A matrix with m rows and n columns can be called an m × n matrix.

Interchange Diagonals

A matrix operation that swaps the elements of the two diagonals (primary and secondary) except for the middle element in the case of an odd-sized matrix.

Individual entries in the matrix are called elements and can be represented by a[i][j] which suggests that the element a is present in the ith row and jth column.

Input

The matrix is defined as:
4 5 6
1 2 3
7 8 9

Output

The matrix after interchanging the elements:
6 5 4
1 2 3
9 8 7

Main Function Approach

In this approach, we bind all the operations together under the ?main' function.

• Step 1: Define and Display the Matrix: The matrix is initialized and then displayed to the user.

for (int i = 0; i < matrix_size; ++i)

	if (i != matrix_size / 2) {

		int temp = input_matrix[i][i];

		input_matrix[i][i] = input_matrix[i][matrix_size - i - 1];

		input_matrix[i][matrix_size - i - 1] = temp;

	}

• Step 2: Swap the Diagonal Elements: This step swaps the elements of the two diagonals.

for (int i = 0; i < matrix_size; ++i)

	if (i != matrix_size / 2) {

		int temp = input_matrix[i][i];

		input_matrix[i][i] = input_matrix[i][matrix_size - i - 1];

		input_matrix[i][matrix_size - i - 1] = temp;

	}

• Step 3: Display the Matrix After Swapping: The matrix is returned after the diagonal elements have been swapped.

System.out.println("\nThe matrix after interchanging the elements: ");

for (int i = 0; i < matrix_size; ++i) {

	for (int j = 0; j < matrix_size; ++j)

		System.out.print(input_matrix[i][j] + " ");

	System.out.println();
}

Example 1

The following is an example of interchanging the diagonals using the main function approach?

public class InterchangeDiagonals {
	public static int matrix_size = 3;
	public static void main (String[] args) {
		int input_matrix[][] = {
			{4, 5, 6},
			{1, 2, 3},
			{7, 8, 9}
		};
		System.out.println("The matrix is defined as: ");
		for (int i = 0; i < matrix_size; i++) {
			for (int j = 0; j < matrix_size; j++) {
				System.out.print(input_matrix[i][j] + " ");
			}
			System.out.println();
		}
		for (int i = 0; i < matrix_size; ++i)
			if (i != matrix_size / 2) {
				int temp = input_matrix[i][i];
				input_matrix[i][i] = input_matrix[i][matrix_size - i - 1];
				input_matrix[i][matrix_size - i - 1] = temp;
			}
		System.out.println("\nThe matrix after interchanging the elements: ");
		for (int i = 0; i < matrix_size; ++i) {
			for (int j = 0; j < matrix_size; ++j)
				System.out.print(input_matrix[i][j]+" ");
			System.out.println();
		}
	}
}

Output

The matrix is defined as:
4 5 6
1 2 3
7 8 9

The matrix after interchanging the elements:
6 5 4
1 2 3
9 8 7

Function-Based Approach

In this approach, we encapsulate the operations into functions exhibiting object-oriented programming.

• Step 1: Define and Display the Matrix: Similar to the previous example, the matrix is initialized and displayed.

int input_matrix[][] = {

	{4, 5, 6},
	{1, 2, 3},

	{7, 8, 9}
};

System.out.println("The matrix is defined as: ");

for (int i = 0; i < matrix_size; i++) {

	for (int j = 0; j < matrix_size; j++) {

		System.out.print(input_matrix[i][j] + " ");
	}

	System.out.println();
}

• Step 2: Create a Function to Swap the Diagonal Elements: The logic for swapping diagonals is moved into a separate function for better organization.

static void interchange_diagonals(int input_matrix[][]) {

	for (int i = 0; i < matrix_size; ++i)

		if (i != matrix_size / 2) {

			int temp = input_matrix[i][i];

			input_matrix[i][i] = input_matrix[i][matrix_size - i - 1];

			input_matrix[i][matrix_size - i - 1] = temp;

		}
}

• Step 3: Call the Function and Display the Matrix: The function is called, and the matrix is printed again after swapping the diagonals.

interchange_diagonals(input_matrix);

System.out.println("\nThe matrix after interchanging the elements: ");

for (int i = 0; i < matrix_size; ++i) {

	for (int j = 0; j < matrix_size; ++j)

		System.out.print(input_matrix[i][j] + " ");

	System.out.println();
}

Example 2

The following is an example of interchanging the diagonals using the function-based approach ?

public class InterchangeDiagonals {
	public static int matrix_size = 3;
	static void interchange_diagonals(int input_matrix[][]) {
		for (int i = 0; i < matrix_size; ++i)
			if (i != matrix_size / 2) {
				int temp = input_matrix[i][i];
				input_matrix[i][i] = input_matrix[i][matrix_size - i - 1];
				input_matrix[i][matrix_size - i - 1] = temp;
			}
		System.out.println("\nThe matrix after interchanging the elements: ");
		for (int i = 0; i < matrix_size; ++i) {
			for (int j = 0; j < matrix_size; ++j)
				System.out.print(input_matrix[i][j]+" ");
			System.out.println();
		}
	}
	public static void main (String[] args) {
		int input_matrix[][] = {
			{4, 5, 6},
			{1, 2, 3},
			{7, 8, 9}
		};
		System.out.println("The matrix is defined as: ");
		for (int i = 0; i < matrix_size; i++) {
			for (int j = 0; j < matrix_size; j++) {
				System.out.print(input_matrix[i][j] + " ");
			}
			System.out.println();
		}
		interchange_diagonals(input_matrix);
	}
}

Output

The matrix is defined as:
4 5 6
1 2 3
7 8 9

The matrix after interchanging the elements:
6 5 4
1 2 3
9 8 7