从最后一列以Z字形打印矩阵

给定n行和n列的二维数组的矩阵。从n-1列开始以ZIG-ZAG方式打印此矩阵，如下图所示。

例子：

Input: mat[][] = 
1 2 3 
4 5 6
7 8 9
Output: 3 2 6 9 5 1 4 8 7

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

算法：

1. 从属于第0行和n-1列的右上角单元格开始遍历。
2. 第一步将始终朝LEFT(WEST)方向。
3. 如果行号为奇数，我们将进行水平/垂直移动。
4. 如果最后的举动是在西北方向，向左移动如果向左没有墙的举动，向下移动的情况下，有在左边墙上。
5. 如果最后的举动是在东南方向，此举如果没有墙DOWNWARDS向下，向左移动的情况下，有一堵墙下。
6. 如果移动被编号为偶数，我们将进行对角移动。
7. 我们选择朝东南和西北方向移动，或者从东南移动开始。
8. 在单个对角线移动中，我们一直沿相同方向遍历多个像元，直到到达矩阵的任何壁。伪代码：

   if ((move_cnt >> 1) & 1) {
        // move south east
   }
   else {
        // move north west
   }
   

Variables Used

• mat: Given NxN matrix
• cur_x: Current row number
• cur_y: Current column number
• prev_move: Used to keep track of previous move
• move_cnt: Used to keep track of number of moves made
• cell_cnt: Used to keep track of number of cells traveresed

下面的代码是上述算法的实现。

C++

// C++ program for traversing a matrix from column n-1
#include 
using namespace std;
  
// Function used for traversing over the given matrix
void traverseMatrix(vector > mat, int n)
{
  
    // Initial cell coordinates
    int cur_x = 0, cur_y = n - 1;
  
    // Variable used for keeping track of last move
    string prev_move = "";
  
    // Variable used for keeping count
    // of cells traversed till next move
    int move_cnt = 1;
    int cell_cnt = 1;
    printf("%d ", mat[cur_x][cur_y]);
  
    while (cell_cnt < n * n) {
  
        // odd numbered move [SINGLE VERTICAL/HORIZONTAL]
        if (move_cnt & 1) {
  
            // last move was made in north east direction
            if (prev_move == "NORTH_WEST" or prev_move == "") {
                // move left
                if (cur_y != 0) {
                    --cur_y;
                    prev_move = "LEFT";
                }
                // move down
                else {
                    ++cur_x;
                    prev_move = "DOWN";
                }
            }
  
            // last move was made in south east direction
            else {
                // move down
                if (cur_x != n - 1) {
                    ++cur_x;
                    prev_move = "DOWN";
                }
                // move left
                else {
                    --cur_y;
                    prev_move = "LEFT";
                }
            }
            printf("%d ", mat[cur_x][cur_y]);
            ++cell_cnt;
        }
  
        // even numbered move/s [DIAGONAL/S]
        else {
            if ((move_cnt >> 1) & 1) {
  
                // move south east
                while (cur_x < n - 1 and cur_y < n - 1) {
                    ++cur_x;
                    ++cur_y;
                    prev_move = "SOUTH_EAST";
                    printf("%d ", mat[cur_x][cur_y]);
                    ++cell_cnt;
                }
            }
            else {
                // move north west
                while (cur_x > 0 and cur_y > 0) {
                    --cur_x;
                    --cur_y;
                    prev_move = "NORTH_WEST";
                    printf("%d ", mat[cur_x][cur_y]);
                    ++cell_cnt;
                }
            }
        }
        ++move_cnt;
    }
}
  
// Driver function
int main()
{
  
    // number of rows and columns
    int n = 5;
  
    // 5x5 matrix
    vector > mat{
        { 1, 2, 3, 4, 5 },
        { 6, 7, 8, 9, 10 },
        { 11, 12, 13, 14, 15 },
        { 16, 17, 18, 19, 20 },
        { 21, 22, 23, 24, 25 }
    };
  
    traverseMatrix(mat, n);
  
    return 0;
}

Java

// Java program for traversing a matrix from column n-1
  
class GFG {
  
    // Function used for traversing over the given matrix
    static void traverseMatrix(int[][] mat, int n)
    {
  
        // Initial cell coordinates
        int cur_x = 0, cur_y = n - 1;
  
        // Variable used for keeping track of last move
        String prev_move = "";
  
        // Variable used for keeping count
        // of cells traversed till next move
        int move_cnt = 1;
        int cell_cnt = 1;
        System.out.print(Integer.toString(
                             mat[cur_x][cur_y])
                         + " ");
  
        while (cell_cnt < n * n) {
  
            // odd numbered move
            // [SINGLE VERTICAL/HORIZONTAL]
            if (move_cnt % 2 == 1) {
                // last move was made in north east direction
                if (prev_move == "NORTH_WEST" || prev_move == "") {
                    // move left
                    if (cur_y != 0) {
                        --cur_y;
                        prev_move = "LEFT";
                    }
                    // move down
                    else {
                        ++cur_x;
                        prev_move = "DOWN";
                    }
                }
  
                // last move was made in south east direction
                else {
  
                    // move down
                    if (cur_x != n - 1) {
                        ++cur_x;
                        prev_move = "DOWN";
                    }
  
                    // move left
                    else {
                        --cur_y;
                        prev_move = "LEFT";
                    }
                }
                System.out.print(Integer.toString(
                                     mat[cur_x][cur_y])
                                 + " ");
                ++cell_cnt;
            }
  
            // even numbered move/s [DIAGONAL/S]
            else {
                if ((move_cnt >> 1) % 2 == 1) {
  
                    // move south east
                    while (cur_x < n - 1 && cur_y < n - 1) {
                        ++cur_x;
                        ++cur_y;
                        prev_move = "SOUTH_EAST";
                        System.out.print(
                            Integer.toString(
                                mat[cur_x][cur_y])
                            + " ");
                        ++cell_cnt;
                    }
                }
                else {
  
                    // move north west
                    while (cur_x > 0 && cur_y > 0) {
                        --cur_x;
                        --cur_y;
                        prev_move = "NORTH_WEST";
                        System.out.print(
                            Integer.toString(
                                mat[cur_x][cur_y])
                            + " ");
                        ++cell_cnt;
                    }
                }
            }
            ++move_cnt;
        }
    }
  
    // Driver function
    public static void main(String[] args)
    {
  
        // number of rows and columns
        int n = 5;
  
        // 5x5 matrix
        int[][] mat = {
            { 1, 2, 3, 4, 5 },
            { 6, 7, 8, 9, 10 },
            { 11, 12, 13, 14, 15 },
            { 16, 17, 18, 19, 20 },
            { 21, 22, 23, 24, 25 }
        };
  
        traverseMatrix(mat, n);
  
        System.exit(0);
    }
}

Python

# Python program for traversing a matrix from column n-1
import sys;
  
# Function used for traversing over the given matrix
def traverseMatrix(mat, n):
  
    # Initial cell coordinates
    cur_x = 0; cur_y = n - 1
  
    # Variable used for keeping track of last move
    prev_move = ""
  
    # Variable used for keeping count 
    # of cells traversed till next move
    move_cnt = 1
    cell_cnt = 1
    print(mat[cur_x][cur_y], end = ' ')
  
    while cell_cnt < n * n:
  
        # odd numbered move [SINGLE VERTICAL / HORIZONTAL]
        if move_cnt & 1: 
  
            # last move was made in north east direction
            if prev_move == "NORTH_WEST" or prev_move == "" :
  
                # move left
                if cur_y != 0:
                    cur_y -= 1 
                    prev_move = "LEFT"
                  
                # move down
                else :
                    cur_x += 1
                    prev_move = "DOWN"
  
            # last move was made in south east direction
            else :
  
                # move down
                if(cur_x != n-1):
                    cur_x += 1
                    prev_move = "DOWN"
  
                # move left
                else :
                    cur_y -= 1
                    prev_move = "LEFT"
              
            print(mat[cur_x][cur_y], end = ' ')
            cell_cnt += 1
  
        # even numbered move / s [DIAGONAL / S]
        else :
            if (move_cnt >> 1) & 1:
  
                # move south east
                while cur_x < n - 1 and cur_y < n - 1:
                    cur_x += 1; cur_y += 1 
                    prev_move = "SOUTH_EAST"
                    print(mat[cur_x][cur_y], end = ' ')
                    cell_cnt += 1
                  
            else :
  
                # move north west
                while cur_x > 0 and cur_y > 0:
                    cur_x -= 1 ; cur_y -= 1
                    prev_move = "NORTH_WEST";
                    print(mat[cur_x][cur_y], end = ' ')
                    cell_cnt += 1
                  
        move_cnt += 1 
  
# Driver function
if __name__ == '__main__':
  
    # number of rows and columns
    n = 5
  
    # 5x5 matrix
    mat =[
         [1,  2,  3,  4,  5],
         [6,  7,  8,  9,  10],
         [11, 12, 13, 14, 15],
         [16, 17, 18, 19, 20],
         [21, 22, 23, 24, 25]
    ]
  
    traverseMatrix(mat, n)

C#

// CSHARP program for traversing a matrix from column n-1
  
using System;
using System.Linq;
  
class GFG {
  
    // Function used for traversing over the given matrix
    static void traverseMatrix(int[, ] mat, int n)
    {
  
        // Initial cell coordinates
        int cur_x = 0, cur_y = n - 1;
  
        // Variable used for keeping track of last move
        string prev_move = "";
  
        // Variable used for keeping count
        // of cells traversed till next move
        int move_cnt = 1;
        int cell_cnt = 1;
        Console.Write(mat[cur_x, cur_y].ToString() + " ");
  
        while (cell_cnt < n * n) {
  
            // odd numbered move [SINGLE VERTICAL/HORIZONTAL]
            if (move_cnt % 2 == 1) {
  
                // last move was made in north east direction
                if (prev_move == "NORTH_WEST" || prev_move == "") {
  
                    // move left
                    if (cur_y != 0) {
                        --cur_y;
                        prev_move = "LEFT";
                    }
  
                    // move down
                    else {
                        ++cur_x;
                        prev_move = "DOWN";
                    }
                }
  
                // last move was made in south east direction
                else {
                    // move down
                    if (cur_x != n - 1) {
                        ++cur_x;
                        prev_move = "DOWN";
                    }
                    // move left
                    else {
                        --cur_y;
                        prev_move = "LEFT";
                    }
                }
                Console.Write(
                    mat[cur_x, cur_y].ToString() + " ");
                ++cell_cnt;
            }
   
            // even numbered move/s [DIAGONAL/S]
            else {
                if ((move_cnt >> 1) % 2 == 1) {
   
                    // Console.WriteLine("[...]");
                    // move south east
                    while (cur_x < n - 1 && cur_y < n - 1) {
                        ++cur_x;
                        ++cur_y;
                        prev_move = "SOUTH_EAST";
                        Console.Write(
                            mat[cur_x, cur_y].ToString()
                            + " ");
                        ++cell_cnt;
                    }
                }
                else {
   
                    // move north west
                    while (cur_x > 0 && cur_y > 0) {
                        --cur_x;
                        --cur_y;
                        prev_move = "NORTH_WEST";
                        Console.Write(
                            mat[cur_x, cur_y].ToString()
                            + " ");
                        ++cell_cnt;
                    }
                }
            }
            ++move_cnt;
        }
    }
  
    // Driver function
    public static void Main()
    {
  
        // number of rows and columns
        int n = 5;
  
        // 5x5 matrix
        int[, ] mat = {
            { 1, 2, 3, 4, 5 },
            { 6, 7, 8, 9, 10 },
            { 11, 12, 13, 14, 15 },
            { 16, 17, 18, 19, 20 },
            { 21, 22, 23, 24, 25 }
        };
  
        traverseMatrix(mat, n);
    }
}

PHP

> 1) & 1) {
  
                # move south east
                while ($cur_x < $n - 1 and $cur_y < $n - 1) {
                    $cur_x += 1; $cur_y += 1;
                    $prev_move = "SOUTH_EAST";
                    print($mat[$cur_x][$cur_y]." ");
                    $cell_cnt += 1;
                }
            }
                  
            else {
  
                # move north west
                while($cur_x > 0 and $cur_y > 0) {
                    $cur_x -=1 ; $cur_y -= 1;
                    $prev_move = "NORTH_WEST";
                    print($mat[$cur_x][$cur_y]." ");
                    $cell_cnt += 1;
                }
            }
        }
                  
        $move_cnt += 1;
    }
} 
  
  
// Driver function
  
# number of rows and columns
$n = 5;
  
#  5x5 matrix
$mat = array(
     array(1,  2,  3,  4,  5),
     array(6,  7,  8,  9,  10),
     array(11, 12, 13, 14, 15),
     array(16, 17, 18, 19, 20),
     array(21, 22, 23, 24, 25)
);
  
traverseMatrix($mat, $n);
?>

输出：

5 4 10 15 9 3 2 8 14 20 25 19 13 7 1 6 12 18 24 23 17 11 16 22 21

时间复杂度：O(N ^ 2)
空间复杂度：O(1)

如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。