力扣题:特定顺序遍历二维数组-10.4

力扣题-10.4

[力扣刷题攻略] Re：从零开始的力扣刷题生活

力扣题1：54. 螺旋矩阵

解题思想：通过定义top,down,left,right四个值来确定边界，然后依次按照从左到右，从上到下，从右到左，从下到上的四个方向进行遍历

class Solution(object):
    def spiralOrder(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: List[int]
        """
        if not matrix:
            return []

        m, n = len(matrix), len(matrix[0])
        top, down, left, right = 0, m - 1, 0, n - 1
        num = 0
        ans = [0] * (m * n)

        while num < m * n:
            if left > right:
                break
            for i in range(left, right + 1):
                ans[num] = matrix[top][i]
                num += 1
            top += 1

            if top > down:
                break
            for i in range(top, down + 1):
                ans[num] = matrix[i][right]
                num += 1
            right -= 1

            if left > right:
                break
            for i in range(right, left - 1, -1):
                ans[num] = matrix[down][i]
                num += 1
            down -= 1

            if top > down:
                break
            for i in range(down, top - 1, -1):
                ans[num] = matrix[i][left]
                num += 1
            left += 1

        return ans

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if (matrix.empty()) {
            return std::vector<int>();
        }

        int m = matrix.size();
        int n = matrix[0].size();
        int top = 0, down = m - 1, left = 0, right = n - 1;
        int num = 0;
        std::vector<int> ans(m * n, 0);

        while (num < m * n) {
            if (left > right) {
                break;
            }
            for (int i = left; i <= right; ++i) {
                ans[num] = matrix[top][i];
                num++;
            }
            top++;

            if (top > down) {
                break;
            }
            for (int i = top; i <= down; ++i) {
                ans[num] = matrix[i][right];
                num++;
            }
            right--;

            if (left > right) {
                break;
            }
            for (int i = right; i >= left; --i) {
                ans[num] = matrix[down][i];
                num++;
            }
            down--;

            if (top > down) {
                break;
            }
            for (int i = down; i >= top; --i) {
                ans[num] = matrix[i][left];
                num++;
            }
            left++;
        }

        return ans;
    }
};

力扣题2：59. 螺旋矩阵 II

解题思想：与上一题类似，往相应的位置进行赋值即可

class Solution(object):
    def generateMatrix(self, n):
        """
        :type n: int
        :rtype: List[List[int]]
        """
        top, down, left, right = 0, n - 1, 0, n - 1
        matrix = [[0 for _ in range(n)] for _ in range(n)]
        num = 1
        while num <= n*n:
            for i in range(left, right + 1):
                matrix[top][i] =num
                num = num+1
            top += 1
            for i in range(top, down + 1):
                matrix[i][right]=num
                num += 1
            right -= 1
            for i in range(right, left - 1, -1):
                matrix[down][i]=num
                num += 1
            down -= 1
            for i in range(down, top - 1, -1):
                matrix[i][left]=num
                num += 1
            left += 1
        return matrix

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int top = 0, down = n - 1, left = 0, right = n - 1;
        std::vector<std::vector<int>> matrix(n, std::vector<int>(n, 0));
        int num = 1;

        while (num <= n * n) {
            for (int i = left; i <= right; ++i) {
                matrix[top][i] = num;
                num++;
            }
            top++;

            for (int i = top; i <= down; ++i) {
                matrix[i][right] = num;
                num++;
            }
            right--;

            for (int i = right; i >= left; --i) {
                matrix[down][i] = num;
                num++;
            }
            down--;

            for (int i = down; i >= top; --i) {
                matrix[i][left] = num;
                num++;
            }
            left++;
        }

        return matrix;
    }
};

力扣题3：498. 对角线遍历

解题思想：分成四种情况进行讨论分析，关键是要确定好边界条件

class Solution(object):
    def findDiagonalOrder(self, mat):
        """
        :type mat: List[List[int]]
        :rtype: List[int]
        """
        
        m = len(mat)
        n = len(mat[0])
        result = []
        for i in range(m + n - 1):
            if i % 2 == 0: 
                if i <= m - 1:
                    x = i
                    y = 0
                    while x >= 0 and y < n:
                        result.append(mat[x][y])
                        x=x-1
                        y=y+1
                else:
                    x = m-1
                    y = i-(m-1)
                    while x >= 0 and y < n:
                        result.append(mat[x][y])
                        x = x-1
                        y = y+1
            else:
                if i <= n - 1:
                    x = 0
                    y = i
                    while x <m and y >=0:
                        result.append(mat[x][y])
                        x = x + 1
                        y = y - 1
                else:
                    x = i-(n-1)
                    y = n-1
                    while x < m and y >= 0:
                        result.append(mat[x][y])
                        x = x + 1
                        y = y - 1
        return result

class Solution {
public:
    vector<int> findDiagonalOrder(vector<vector<int>>& mat) {
        int m = mat.size();
        int n = mat[0].size();
        int num=0;
        int x=0,y=0;
        std::vector<int> result(m * n, 0);
        for(int i=0;i<m+n-1;i++)
        {
            if(i%2==0)
            {
                if(i<=m-1)
                {
                    x=i;
                    y=0;
                    while(x>=0&&y<n)
                    {
                        result[num] = mat[x][y];
                        num++;
                        x--;
                        y++;
                    }
                }
                else
                {
                    x=m-1;
                    y=i-(m-1);
                    while(x>=0&&y<n)
                    {
                        result[num] = mat[x][y];
                        num++;
                        x--;
                        y++;
                    }
                }
            }
            else
            {
                if(i<=n-1)
                {
                    x=0;
                    y=i;
                    while(x<m&&y>=0)
                    {
                        result[num] = mat[x][y];
                        num++;
                        x++;
                        y--;
                    }
                }
                else
                {
                    x=i-(n-1);
                    y=n-1;
                    while(x<m&&y>=0)
                    {
                        result[num] = mat[x][y];
                        num++;
                        x++;
                        y--;
                    }
                }
            }
        }
        return result;
    }
};