按块顺序读取大数组的实现方案咨询

看起来你需要按行优先的块级顺序遍历大数组（先扫完一行的所有数据块，再进入下一行的块，每个块内部也按行优先读取）——这在处理分块存储的矩阵、图像数据时非常常见。我给你整理了几种主流语言的实现示例，核心逻辑都是先定位块的起始位置，再遍历块内元素。

核心逻辑梳理 #

先明确几个参数定义（以你提到的16×16块、每块16×16元素为例）：

• 块网格尺寸：block_rows = 16，block_cols = 16（大数组被分成16行16列的块）
• 单块尺寸：block_size = 16（每个块包含16行16列的元素）
• 大数组总尺寸：total_rows = block_rows * block_size = 256，total_cols = block_cols * block_size = 256

遍历顺序拆解：

1. 外层遍历块的行（从第0块行到第15块行）
2. 中层遍历当前块行内的所有块列（从第0块列到第15块列）
3. 内层遍历当前块内的所有元素（按行优先顺序）

Python 实现示例 #

def traverse_by_blocks(large_array, block_rows=16, block_cols=16, block_size=16):
    traversed_data = []
    # 遍历每一行的块
    for block_row_idx in range(block_rows):
        # 遍历当前块行中的每一列块
        for block_col_idx in range(block_cols):
            # 计算当前块的起始行、列索引
            block_start_row = block_row_idx * block_size
            block_start_col = block_col_idx * block_size
            # 遍历块内的每一行
            for row_in_block in range(block_size):
                current_row = block_start_row + row_in_block
                # 遍历当前行的每一列元素
                for col_in_block in range(block_size):
                    current_col = block_start_col + col_in_block
                    traversed_data.append(large_array[current_row][current_col])
    return traversed_data

# 测试用例：生成一个256×256的测试数组
import numpy as np
test_array = np.arange(256*256).reshape(256, 256).tolist()
result = traverse_by_blocks(test_array)
# 验证顺序：前256个元素是第(0,0)块的所有值，接下来256个是(0,1)块，以此类推
print("前10个遍历结果：", result[:10])

C++ 实现示例 #

#include <vector>
#include <iostream>

using namespace std;

vector<int> traverseByBlocks(const vector<vector<int>>& largeArray,
                            int blockRows = 16, int blockCols = 16, int blockSize = 16) {
    vector<int> traversedResult;
    int totalRows = blockRows * blockSize;
    int totalCols = blockCols * blockSize;

    // 遍历块行
    for (int blockRow = 0; blockRow < blockRows; ++blockRow) {
        // 遍历当前块行的块列
        for (int blockCol = 0; blockCol < blockCols; ++blockCol) {
            int startRow = blockRow * blockSize;
            int startCol = blockCol * blockSize;
            // 遍历块内的每一行
            for (int rowOffset = 0; rowOffset < blockSize; ++rowOffset) {
                int currentRow = startRow + rowOffset;
                // 遍历当前行的每一列
                for (int colOffset = 0; colOffset < blockSize; ++colOffset) {
                    int currentCol = startCol + colOffset;
                    traversedResult.push_back(largeArray[currentRow][currentCol]);
                }
            }
        }
    }
    return traversedResult;
}

int main() {
    // 构建256×256的测试数组
    vector<vector<int>> testArray(256, vector<int>(256));
    int value = 0;
    for (int i = 0; i < 256; ++i) {
        for (int j = 0; j < 256; ++j) {
            testArray[i][j] = value++;
        }
    }

    vector<int> result = traverseByBlocks(testArray);
    // 打印前10个元素验证顺序
    cout << "前10个遍历结果：";
    for (int i = 0; i < 10; ++i) {
        cout << result[i] << " ";
    }
    cout << endl;
    return 0;
}

优化小技巧 #

如果你的大数组是一维连续存储（比如用Python的列表、C++的原生数组），可以直接通过索引计算跳过嵌套循环，效率更高：

# 一维数组的遍历示例
def traverse_1d_by_blocks(large_array_1d, block_rows=16, block_cols=16, block_size=16):
    total_cols = block_cols * block_size
    traversed_data = []
    for block_row in range(block_rows):
        for block_col in range(block_cols):
            block_start_idx = (block_row * block_size) * total_cols + (block_col * block_size)
            # 遍历块内的每一行
            for row_in_block in range(block_size):
                row_start_idx = block_start_idx + row_in_block * total_cols
                # 取当前行的block_size个元素
                traversed_data.extend(large_array_1d[row_start_idx : row_start_idx + block_size])
    return traversed_data

内容的提问来源于stack exchange，提问作者bitQUAKE