对角线矩阵镜像的Python程序

给定一个 N x N 阶的二维数组，打印一个矩阵，它是给定树在对角线上的镜像。我们需要以某种方式打印结果：将对角线上方的三角形的值与其下方的三角形的值交换，就像镜像交换一样。打印以矩阵布局获得的二维数组。

例子：

Input : int mat[][] = {{1 2 4 }
                       {5 9 0}
                       { 3 1 7}}
Output :  1 5 3 
          2 9 1
          4 0 7

Input : mat[][] = {{1  2  3  4 }
                   {5  6  7  8 }
                   {9  10 11 12}
                   {13 14 15 16} }
Output : 1 5 9 13 
         2 6 10 14  
         3 7 11 15 
         4 8 12 16

这个问题的一个简单解决方案涉及额外的空间。我们一一遍历所有右对角线（从右到左）。在对角线的遍历过程中，首先将所有元素压入栈中，然后再次遍历，将对角线的每个元素替换为栈元素。

下面是上述思想的实现。

Python3

# Simple Python3 program to find mirror of
# matrix across diagonal.
MAX = 100
  
def imageSwap(mat, n):
      
    # for diagonal which start from at 
    # first row of matrix
    row = 0
      
    # traverse all top right diagonal
    for j in range(n):
          
        # here we use stack for reversing
        # the element of diagonal
        s = []
        i = row
        k = j
        while (i < n and k >= 0):
            s.append(mat[i][k])
            i += 1
            k -= 1
              
        # push all element back to matrix 
        # in reverse order
        i = row
        k = j
        while (i < n and k >= 0):
            mat[i][k] = s[-1]
            k -= 1
            i += 1
            s.pop()
              
    # do the same process for all the
    # diagonal which start from last
    # column
    column = n - 1
    for j in range(1, n): 
          
        # here we use stack for reversing 
        # the elements of diagonal
        s = []
        i = j
        k = column
        while (i < n and k >= 0):
            s.append(mat[i][k])
            i += 1
            k -= 1
              
        # push all element back to matrix 
        # in reverse order
        i = j
        k = column
        while (i < n and k >= 0):
            mat[i][k] = s[-1]
            i += 1
            k -= 1
            s.pop()
  
# Utility function to pra matrix
def printMatrix(mat, n):
    for i in range(n):
        for j in range(n):
            print(mat[i][j], end=" ")
        print()
          
# Driver code
mat = [[1, 2, 3, 4],[5, 6, 7, 8],
        [9, 10, 11, 12],[13, 14, 15, 16]]
n = 4
imageSwap(mat, n)
printMatrix(mat, n)
  
# This code is contributed by shubhamsingh10

Python3

# Efficient Python3 program to find mirror of
# matrix across diagonal.
from builtins import range
MAX = 100;
  
def imageSwap(mat, n):
  
    # traverse a matrix and swap
    # mat[i][j] with mat[j][i]
    for i in range(n):
        for j in range(i + 1):
            t = mat[i][j];
            mat[i][j] = mat[j][i]
            mat[j][i] = t
  
# Utility function to pra matrix
def printMatrix(mat, n):
    for i in range(n):
        for j in range(n):
            print(mat[i][j], end=" ");
        print();
  
# Driver code
if __name__ == '__main__':
    mat = [1, 2, 3, 4], \
        [5, 6, 7, 8], \
        [9, 10, 11, 12], \
        [13, 14, 15, 16];
    n = 4;
    imageSwap(mat, n);
    printMatrix(mat, n);
  
# This code is contributed by Rajput-Ji
Output: 1 5 9 13 
2 6 10 14 
3 7 11 15 
4 8 12 16 Time complexity : O(n*n) Please refer complete article on Mirror of matrix across diagonal for more details!

输出：

时间复杂度： O(n*n)

这个问题的一个有效解决方案是，如果我们观察一个输出矩阵，那么我们注意到我们只需要交换 (mat[i][j] 到 mat[j][i])。
下面是上述思想的实现。

Python3

# Efficient Python3 program to find mirror of
# matrix across diagonal.
from builtins import range
MAX = 100;
  
def imageSwap(mat, n):
  
    # traverse a matrix and swap
    # mat[i][j] with mat[j][i]
    for i in range(n):
        for j in range(i + 1):
            t = mat[i][j];
            mat[i][j] = mat[j][i]
            mat[j][i] = t
  
# Utility function to pra matrix
def printMatrix(mat, n):
    for i in range(n):
        for j in range(n):
            print(mat[i][j], end=" ");
        print();
  
# Driver code
if __name__ == '__main__':
    mat = [1, 2, 3, 4], \
        [5, 6, 7, 8], \
        [9, 10, 11, 12], \
        [13, 14, 15, 16];
    n = 4;
    imageSwap(mat, n);
    printMatrix(mat, n);
  
# This code is contributed by Rajput-Ji

输出：

时间复杂度： O(n*n)

有关详细信息，请参阅关于矩阵对角线镜像的完整文章！

在评论中写代码？请使用 ide.geeksforgeeks.org，生成链接并在此处分享链接。