python用while对二维数组进行遍历

可以使用while嵌套循环对二维数组进行遍历，示例代码如下：

array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
i = 0
while i < len(array):
    j = 0
    while j < len(array[i]):
        print(array[i][j])
        j += 1
    i += 1

这段代码会打印出二维数组中每一个元素的值。其中，外层的while循环控制行数，内层的while循环控制列数。

相关问题

python二维数组回形遍历

以下是Python实现二维数组回形遍历的代码示例：

def spiralOrder(matrix):
    if not matrix:
        return []
    m, n = len(matrix), len(matrix[0])
    left, right, top, bottom = 0, n - 1, 0, m - 1
    res = []
    while left <= right and top <= bottom:
        for i in range(left, right + 1):
 res.append(matrix[top][i])
        top += 1
        for i in range(top, bottom + 1):
            res.append(matrix[i][right])
        right -= 1
        if top <= bottom:
            for i in range(right, left - 1, -1):
                res.append(matrix[bottom][i])
            bottom -= 1
        if left <= right:
            for i in range(bottom, top - 1, -1):
                res.append(matrix[i][left])
            left += 1
    return res

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
result = spiralOrder(matrix)
print(result)  # 输出：[1, 2, 3, 6, 9, 8, 7, 4, 5]

对于一个n*m的二维网格，可以将其顺时针遍历变成一维数组。遍历方法为：自左上角起始（起始下标记作1）顺时针开始遍历，在碰到边界或已遍历的位置时，顺时针旋转90度，直至最后一个数。现给你顺时针遍历的一个下标k，求出该方格的坐标（i，j）。

首先，我们需要确定起始位置以及每个方向的边界。我们可以通过以下方法来确定：

假设矩阵的大小为n行m列，起始位置为(0,0)，则可以得到每个方向的边界：

向右：(0,m-1)；向下：(n-1,m-1)；向左：(n-1,0)；向上：(1,0)

接下来，我们需要确定k所在的方向以及在该方向上的位置。我们可以通过以下方法来确定：

假设当前方向为向右，边界坐标为(0,m-1)，则k所在的方向为向右，并且k所在的位置为k-1。

如果k在向下的方向上，我们可以将起始位置向下移动一行，并将当前方向改为向下。边界坐标为(n-1,m-1)。此时，k所在的位置为k-m。

如果k在向左的方向上，我们可以将起始位置向下移动一行，并将当前方向改为向左。边界坐标为(n-1,0)。此时，k所在的位置为n×m-k+1。

如果k在向上的方向上，我们可以将起始位置向上移动一行，并将当前方向改为向上。边界坐标为(1,0)。此时，k所在的位置为n×m-2×m-k+3。

最后，我们可以将得到的坐标i和j加上起始位置的行列值即可。

下面是Python代码实现：

def findCoord(n, m, k):
    i, j = 0, 0
    direction = 0
    left, right, up, down = 0, m - 1, 0, n - 1

    while left <= right and up <= down:
        if direction == 0:
            if k <= right:
                j = k
                i = up
                break
            else:
                k -= right
                up += 1
                direction = 1
        elif direction == 1:
            if k <= down:
                i = k
                j = right
                break
            else:
                k -= down
                right -= 1
                direction = 2
        elif direction == 2:
            if k <= right:
                j = k
                i = down
                break
            else:
                k -= right
                down -= 1
                direction = 3
        else:
            if k <= down:
                i = down - k + 1
                j = left
                break
            else:
                k -= down
                left += 1
                direction = 0

    return i, j