交换矩阵中任意两列的Java程序

给定一个具有 m 行和 n 列的矩阵。我们必须编写一个Java程序来交换给定矩阵中的任意两列（即输入中没有给出 K 和 L 的列）。需要交换操作来交换两列的元素。交换两列的 O(1) 操作是不可能的，因为需要在两列之间完成遍历。

例子

Input 1: K = 1, L = 2,
        mat[][] = {{2, 1, 4},
                   {1, 2, 3},  
                   {3, 6, 2}}
                 
Output: mat[][] = {{1,2, 4},
                   {2,1, 3},  
                   {6,3, 2}}
                         
Input 2: K = 1, L = 1,
             mat[][] = {{2, 1, 4},
                        {1, 2, 3}}
                         
Output: mat[][] = {{2, 1, 4},
                   {1, 2, 3}}
                          
Input 3: K = 1, L = 3,
              mat[][] = {{2, 1,8},
                         {1, 2,9},  
                         {3, 6,5}}   
                              
Output:    {{8, 1,2},
            {9, 2,1},  
            {5, 6,3}}                        

方法

• 如果 K 和 L 即我们必须交换的列号相同，则按原样打印矩阵。
• Else 循环遍历矩阵的第 K 列和第 L 列。
• 在遍历的同时交换两个列的索引的元素。
• 现在循环结束后，打印矩阵。

下面是上述方法的代码实现：

Java

// Java program to interchange
// two Column in a Matrix
import java.io.*;
class GFG {
  
    public static void printMatrix(int[][] matrix)
    {
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++)
                System.out.print(matrix[i][j] + " ");
            System.out.println();
        }
    }
    public static void exchangeAnyTwoColumns(int[][] matrix,
                                             int K, int L)
    {
        for (int i = 0; i < matrix.length; i++) {
  
            // Swap two numbers
            int temp = matrix[i][K - 1];
            matrix[i][K - 1] = matrix[i][L - 1];
            matrix[i][L - 1] = temp;
        }
  
        // Print matrix
        printMatrix(matrix);
    }
  
    public static void main(String[] args)
    {
        int K = 1, L = 2;
        int mat[][]
            = { { 2, 1, 4 }, { 1, 2, 3 }, { 3, 6, 2 } };
  
        // calling the exchange Column fuction
        exchangeAnyTwoColumns(mat, K, L);
    }
}

输出

1 2 4 
2 1 3 
6 3 2 

时间复杂度： 0(n)，其中 n 是列的长度。

空间复杂度： 0(1)