跨对角线矩阵镜像的Javascript程序

给定一个 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 

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

下面是上述思想的实现。

Javascript

    
    // Simple Javascript program to find mirror of matrix across diagonal.
      
    let MAX = 100;
   
    function imageSwap(mat, n)
    {
        // for diagonal which start from at
        // first row of matrix
        let row = 0;
   
        // traverse all top right diagonal
        for (let j = 0; j < n; j++)
        {
   
            // here we use stack for reversing
            // the element of diagonal
            let s = [];
            let i = row, k = j;
            while (i < n && k >= 0)
            {
                s.push(mat[i++][k--]);
            }
   
            // push all element back to matrix
            // in reverse order
            i = row;
            k = j;
            while (i < n && k >= 0)
            {
                mat[i++][k--] = s[s.length - 1];
                s.pop();
            }
        }
   
        // do the same process for all the
        // diagonal which start from last
        // column
        let column = n - 1;
        for (let j = 1; j < n; j++)
        {
   
            // here we use stack for reversing
            // the elements of diagonal
            let s = [];
            let i = j, k = column;
            while (i < n && k >= 0)
            {
                s.push(mat[i++][k--]);
            }
   
            // push all element back to matrix
            // in reverse order
            i = j;
            k = column;
            while (i < n && k >= 0)
            {
                mat[i++][k--] = s[s.length - 1];
                s.pop();
            }
        }
    }
   
    // Utility function to print a matrix
    function printMatrix(mat, n)
    {
        for (let i = 0; i < n; i++)
        {
            for (let j = 0; j < n; j++)
            {
                document.write(mat[i][j] + " ");
            }
            document.write("</br>");
        }
    }
      
    let mat = [[1, 2, 3, 4],
               [5, 6, 7, 8],
               [9, 10, 11, 12],
               [13, 14, 15, 16]];
    let n = 4;
    imageSwap(mat, n);
    printMatrix(mat, n);
      

输出：

1 5 9 13 
2 6 10 14 
3 7 11 15 
4 8 12 16

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

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

Javascript

    // Efficient Javascript program to find mirror of
    // matrix across diagonal.
      
    let MAX = 100;
        
    function imageSwap(mat, n)
    {
            
        // traverse a matrix and swap 
        // mat[i][j] with mat[j][i]
        for (let i = 0; i < n; i++)
            for (let j = 0; j <= i; j++) 
                mat[i][j] = mat[i][j] + mat[j][i]
                       - (mat[j][i] = mat[i][j]);     
    }
        
    // Utility function to print a matrix
    function printMatrix(mat, n)
    {
        for (let i = 0; i < n; i++) {
            for (let j = 0; j < n; j++)
                document.write(mat[i][j] + " ");
            document.write("</br>");
        }
    }
      
    let mat = [ [ 1, 2, 3, 4 ],
                [ 5, 6, 7, 8 ],
                [ 9, 10, 11, 12 ],
                [ 13, 14, 15, 16 ] ];
    let n = 4;
    imageSwap(mat, n);
    printMatrix(mat, n);
        

输出：

1 5 9 13 
2 6 10 14 
3 7 11 15 
4 8 12 16 

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

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