MATLAB for循环遍历矩阵：逐行逐列与逐元素处理及性能优化-代码聚汇网

MATLAB for循环遍历矩阵：逐行逐列与逐元素处理及性能优化

流浪小鱼·2026-08-29·阅读 25 GEO检测（免费）

MATLABfor循环矩阵遍历

|难度：普通|阅读约 28 分钟

在MATLAB里写for循环遍历矩阵，大概是每个新手最先学会、又被老手劝退的操作。我在带学生做项目时，几乎每次讲到矩阵处理，都会有人问：为什么别人说循环慢，但有时候又不得不用？为什么我写的双重循环跑起来像老牛拉车？其实问题不在循环本身，而在你对矩阵在内存里的排列方式、遍历方向、预分配这些细节了解多少。这篇文章就围绕“MATLAB for循环遍历矩阵”这条主线，把逐行遍历、逐列遍历、逐元素处理以及性能调优方法完整走一遍，适合刚接触MATLAB的初学者，也适合写了一阵子但没深究过性能的人参考。

标题里提到的“逐行/列遍历与逐元素处理”，翻译成实际操作，无非是三类场景：按行做统计、按列做变换、对每个元素做判断或计算。这些场景如果选错遍历顺序，轻则效率低，重则会写出难以调试的逻辑错误。下面我按实际使用频率，一步步拆开讲。

1. 先搞清楚矩阵的“底层脾气”：列优先存储与线性下标

很多人在写循环遍历时，默认矩阵是按数学课本上那种“行优先”排列的——先第一行从左到右，再第二行。但MATLAB的存储逻辑完全不同，它按列优先存放数据。也就是说，A = [1 2 3; 4 5 6]保存到内存时，顺序是1、4、2、5、3、6。这个底层事实，直接决定了你遍历时快不快。

1.1 为什么遍历方向会影响性能

因为CPU访问连续内存地址的速度远高于跳来跳去，所以遍历顺序如果跟存储顺序一致，就能最大限度利用缓存。在MATLAB里，按列访问比按行访问通常更快，原因就在于它是列优先存储。

很多初学者喜欢写成：

matlab复制for i = 1:size(A,1)
    for j = 1:size(A,2)
        value = A(i,j);
    end
end

这个写法逻辑没错，但在这里，i是行索引，j是列索引，内层循环j变化时，访问的是A(i,1)、A(i,2)、A(i,3)……这恰恰是在内存里跳着访问的。列数一大，缓存命中率会明显下降。

1.2 用size和numel确定遍历边界

写遍历前先问自己三个问题：要遍历多少行？多少列？总共多少个元素？回答这些问题的标准工具是size和numel。

matlab复制A = rand(8, 10);
rows = size(A,1);   % 8
cols = size(A,2);   % 10
total = numel(A);   % 80

numel返回总元素数，它跟prod(size(A))等价。对于矩阵遍历，numel是最好用的边界值，尤其是在后面要讲的线性索引遍历里。这里有个小习惯：在进入循环前，预先计算循环边界并赋给变量，而不是每次循环都调用size(A,1)。虽然MATLAB的JIT编译会在一定程度上优化，但提前计算不仅更清晰，也减少不必要的函数调用开销。

1.3 一个最简单的逐元素遍历示例

按列优先存储的结论，落到代码上就是：如果你只想要遍历所有元素，而不关心行列坐标，最自然的方式是单层循环+线性索引：

matlab复制A = magic(5);
s = 0;
for k = 1:numel(A)
    s = s + A(k);
end

这里A(k)是线性索引，MATLAB中k从1到numel(A)，沿着存储顺序依次取出每个元素。初学者可能不太适应这种写法，但它在性能上通常优于嵌套循环，也更简洁。真正需要A(i,j)坐标时，再用嵌套循环也不迟。

1.4 如何验证存储顺序

如果你想知道一件事在MATLAB里到底是行优先还是列优先，做个实验就行：

matlab复制A = [1 2 3; 4 5 6];
A(:)  % 得到 [1;4;2;5;3;6]

用一次A(:)就能看到线性展开结果，直接证实列优先。这个知识点在后续的reshape、repmat、图像处理中也会反复出现，提前理解，能省掉不少调试时间。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 逐行遍历：写法直观，但要注意读取方向

逐行遍历最常见的场景是：每一行是一个样本、一个时间步或一条数据记录，需要按行做归一化、提取特征或输出格式化结果。它的代码模板很固定，核心是用size(A,1)作为外层循环上限。

2.1 标准写法：外层行、内层列

matlab复制A = rand(50, 20);
for i = 1:size(A,1)
    row_sum = 0;
    for j = 1:size(A,2)
        row_sum = row_sum + A(i,j);
    end
    fprintf('第%d行元素之和: %.4f\n', i, row_sum);
end

这个例子偏教学向，实际要算行和直接sum(A,2)就行。但它的意义在于展示“外层行、内层列”的顺序。如果你要把每一行拿出来交给某个子函数处理，也可以写成：

matlab复制for i = 1:size(A,1)
    row_data = A(i, :);
    processRow(row_data);
end

这里用A(i,:)切片获取整行，然后传递下去。优点是逻辑非常清晰，代码可读性高。缺点是切片操作本身会复制数据，如果行很长且循环次数很多，内存和耗时都会上升。对性能敏感的代码，建议按列存储数据、按列遍历，或者用线性索引。

2.2 逐行遍历的真实场景：批量归一化

举一个我实际处理过的例子。某个传感器实验得到50组采样，每组2000个点，存成50×2000的矩阵。我需要把每一行的数据缩放到0到1之间。新手写法可能是：

matlab复制for i = 1:size(data,1)
    maxv = max(data(i,:));
    minv = min(data(i,:));
    data(i,:) = (data(i,:) - minv) / (maxv - minv);
end

这段代码在数据量小的时候完全没问题，逻辑也好懂。但如果数据变成5000×20000，这个逐行切片和赋值就会非常慢。更合适的方式是先算出行最大值和最小值，再用向量化操作一次搞定：

matlab复制maxv = max(data, [], 2);
minv = min(data, [], 2);
data = (data - minv) ./ (maxv - minv);

这就是典型的“先想清楚能否向量化”的例子。向量化以后再也不用循环了，运行速度可能快几十倍。我后面会专门用一节对比性能。

2.3 逐行遍历的常见坑：循环内修改矩阵

按行遍历时，如果修改了矩阵的行，要特别小心后续行的索引是否会受影响。例如你要删除某些行，最后再统一删，千万别在循环里直接A(i,:)=[]，因为删除后矩阵大小变了，索引会错位。我在调试类似代码时被坑过一次，排查了半天才发现是循环内删行导致的行号错乱。正确的做法是先用逻辑变量记录要删除的行，循环结束后一次性删除。

3. 逐列遍历：更贴近MATLAB内存布局的选择

如果你已经理解了列优先存储，那逐列遍历的动机就很简单了：大部分情况下，它比逐行遍历快。所谓逐列遍历，就是外层循环控制列号，内层循环控制行号。

3.1 标准写法：外层列、内层行

matlab复制A = rand(50, 20);
for j = 1:size(A,2)
    col_sum = 0;
    for i = 1:size(A,1)
        col_sum = col_sum + A(i,j);
    end
    fprintf('第%d列之和: %.4f\n', j, col_sum);
end

这段代码的内层循环i变化时，访问的地址是A(1,j), A(2,j), A(3,j)……，正好沿着内存方向连续移动，缓存更友好。实际测试里，这种写法往往比“外层行、内层列”快不少。

不过，如果你真的只是为了求每一列的和，直接用sum(A,1)就行了，千万不要为了用循环而用循环。循环的适用场景是：必须按列进行某种顺序依赖的递推，或者每一列都要调用一个无法向量化的函数，又或者需要同时维护多个与列相关的状态变量。

3.2 逐列遍历的实际案例：按列积分

我有一次做光谱数据处理，4000个波长点，600个样本，想要对每个样本的谱线做数值积分。MATLAB里当然可以用trapz(A)直接对所有列积分，但为了在积分前做一系列条件过滤和异常点剔除，最后还是写了逐列遍历：

matlab复制results = zeros(1, size(data,2));
for j = 1:size(data,2)
    col = data(:,j);
    col(col < 0) = NaN; % 剔除负值
    col = fillmissing(col, 'linear'); % 线性插值
    results(j) = trapz(col);
end

这个例子中，每一列的数据处理链条比较长，每一步都依赖列内部的情况，向量化不是不行，但可读性会差很多。这时候逐列循环反而是更好的选择。代码也符合MATLAB存储顺序，性能可接受。

3.3 什么时候逐列比逐行慢

凡事都有例外。如果你的操作是以整行为单位，并且每行的数据量很大，那么逐行切片再调用某个函数，可能比逐列切片更快，因为行切片得到的是一个完整向量，而逐列切片也是完整向量，两者本质上都是切片，只是存储顺序不同。真正的瓶颈往往不在遍历方向，而在切片和函数调用。所以我的经验是：先尽量向量化，实在不能向量化，再优先考虑逐列；如果逻辑上按行更自然，先写着，再用性能分析器验证。

4. 逐元素处理：从嵌套循环到优雅的单层循环

逐元素处理是我在图像处理和数值计算里用得最多的需求。比如对图像每个像素做阈值判断、对矩阵每个元素加一个噪声、把负数清零。这类需求通常有两种写法：嵌套循环和单层线性索引循环。

4.1 双重for循环的直接写法

matlab复制A = rand(100, 100);
B = zeros(size(A));
for i = 1:size(A,1)
    for j = 1:size(A,2)
        if A(i,j) > 0.5
            B(i,j) = A(i,j)^2;
        else
            B(i,j) = 0;
        end
    end
end

这个写法非常直观，适合新手理解。但问题也很明显：在for循环里逐元素判断和赋值，执行效率不高；而且一旦矩阵维度变成三维甚至更高维，嵌套层数会爆炸。对于这种简单的逐元素判断，用逻辑索引一行就能解决：

matlab复制B = zeros(size(A));
mask = A > 0.5;
B(mask) = A(mask).^2;

这才是在MATLAB里处理逐元素问题的正确打开方式。逻辑索引天然支持逐元素操作，而且写出来就是“思维直译”：大于0.5的地方执行平方，其它地方置零。这里的重点不是禁止for循环，而是不要在能用矩阵运算的地方硬写for循环。

4.2 单层线性索引循环：兼顾效率与灵活性的折中

如果处理过程真的依赖元素的邻域，或者需要对每个元素做很复杂的条件分支，那么完全可以使用单层循环加线性索引：

matlab复制A = rand(100, 100);
B = zeros(size(A));
for k = 1:numel(A)
    val = A(k);
    if val > 0.5
        B(k) = val^2;
    else
        B(k) = 0;
    end
end

这个写法把双重循环降为一重，代码更紧凑，也避免了按行/列顺序问题。内存访问顺序与存储顺序一致，速度通常优于嵌套循环。但要注意，如果你在B(k)赋值时使用的是矩阵的线性位置，那么B也要通过B(k)来赋值，这样才不会破坏行列结构。

4.3 从行列坐标转换到线性索引

有时你在循环里已经拿到了i和j，但又要用线性索引访问或赋值，可以利用sub2ind和ind2sub两个函数做转换。

matlab复制[idx] = sub2ind(size(A), i, j);  % 行列转线性
[i, j] = ind2sub(size(A), idx);  % 线性转行列

这两个函数在遍历不规则子区域时特别有用。比如只遍历矩阵左上三角部分，用双重循环加j >= i条件，也可以用线性索引和三角矩阵的掩码组合配合find函数实现。我自己更倾向后者，因为掩码方法可读性好，也容易扩展到三维矩阵。

4.4 循环体内不要犯的错：改变循环变量

在for循环内给循环变量重新赋值，是一件非常危险的事情。比如：

matlab复制for i = 1:10
    i = i + 1;  % 不要这么干
end

MATLAB的for循环在循环变量上不会像C语言那样“每次迭代检查并递增”，它是在循环开始时生成一个行向量，然后逐个取出元素。因此你在循环体内修改i，只影响本次迭代的i值，不会改变循环的总次数。但这样做会让代码混乱，别人看的时候根本不知道你在想什么。我见过有人靠修改i来“跳过”某些索引，结果完全没生效，因为应该用continue或break。

5. 内存预分配与性能陷阱：实测数据说明一切

性能问题往往是新手最容易忽略的。在MATLAB里写循环，最大的性能杀手不是循环本身，而是——数组动态增长。

5.1 为什么未预分配会慢到怀疑人生

想象一下，你写了一个循环，每次往结果矩阵里多塞一个元素：

matlab复制tic;
result = [];
for k = 1:100000
    result(k) = k^2;
end
toc;

这段代码的问题在于，result初始是空数组，第一次循环时它需要重新分配一个1×1的数组，第二次需要重新分配1×2的数组，然后把旧数据复制过去……随着循环推进，重复分配和复制的代价越来越大。虽然MATLAB的JIT编译会做一些优化，但对动态增长的数组，仍然可能非常慢。实测中，100万次循环，不做预分配耗时可能比预分配多出几十倍。

5.2 预分配的不同方式及其选择

常见的预分配方式有：

matlab复制result = zeros(1, 100000);       % 最常用，默认double矩阵
result = zeros(1, 100000, 'single'); % 单精度
result = NaN(1, 100000);         % 如果填的是数值
result = cell(1, 100000);        % 如果每个元素是不同类型/长度

如果你不确定最终维度，至少也要预先分配一个大致的空间，或者用cell来避免反复扩展。另外，预分配不只是给结果矩阵，临时变量如果确定大小，也应该预分配，比如你要在循环里缓存每轮处理的结果。

5.3 实测对比：预分配 vs 动态增长

我做过一次简单测试：对20000个元素做平方存储，分别用动态增长和预分配。环境是MATLAB R2023a，时间如下：

写法	平均耗时（秒）	备注
动态增长 `result(k)=...`	0.23	小规模还不太明显
预分配 `result=zeros(1,20000)`	0.001	快了两个数量级

当数据量到20万时，动态增长到了十几秒，预分配仍然几乎瞬间完成。这个差距足以说明，写循环第一步永远是画好结果矩阵的“格子”。如果你担心预先分配的大小不对，可以用inf或NaN占位，最后再删掉多余部分。

5.4 还有一类隐藏性能问题：切片复制

不只是结果矩阵，循环里频繁使用的切片操作也会制造性能瓶颈。比如：

matlab复制for i = 1:size(A,1)
    row = A(i,:);
    process(row);
end

如果process是某个外部函数，每次调用都要拷贝这一行，拷贝成本随列数线性上升。如果你要频繁按行读取，可以考虑转置矩阵后按列遍历，这样切片操作与存储顺序一致。当然，最好的做法还是把process改造成支持矩阵输入，一次性处理。

6. 向量化替代：用矩阵运算解决80%的遍历需求

“MATLAB的for循环很慢”这句话不够准确。准确的说法是：如果你的for循环里做的操作原本可以用矩阵运算表达，那你就是舍弃了MATLAB最核心的优势。 向量化并不是一种投机取巧的技巧，它本身就是MATLAB的设计哲学。

6.1 首先判断：这个遍历真的需要循环吗

我总结了三个“不需要循环”的信号：

对矩阵每个元素独立做同一个运算，无顺序依赖。
要对每行/每列做聚合操作（求和、均值、最大值等）。
要按某个规则筛选元素。

针对这三类需求，替代品分别是：

点运算：A.^2、sin(A)、exp(A)。
维度聚合：sum(A,1)、sum(A,2)、max(A,[],1)。
逻辑索引：A(A>0)、find(A>0)。

比如要统计矩阵里所有大于0的元素个数，不要再写循环了：

matlab复制count = sum(A(:) > 0);

就这么一行。读取A(:)把所有元素展成列向量，比较后得到逻辑向量，sum统计真值个数。如果需要得到这些元素的位置索引，用find。

6.2 用逻辑索引做逐元素条件处理

前面提到的阈值处理，最优雅的写法就是用逻辑索引。再举一个复杂一点的例子：将矩阵中所有偶数替换为-1，所有奇数替换为1。

matlab复制A = randi(10, 5, 5);
B = ones(size(A));
B(mod(A, 2) == 0) = -1;

这里mod(A,2)==0产生一个逻辑矩阵，直接索引出需要赋值的位置。整个过程没有循环，但本质上已经对每个元素做了条件判断，这就是向量化替代的威力。

6.3 arrayfun和cellfun是不是灵丹妙药

有些人在不能用矩阵运算时就想到arrayfun，它允许你把一个自定义函数应用到数组每个元素上：

matlab复制A = rand(100,100);
B = arrayfun(@myFunc, A);

这个函数看起来是在“隐式地遍历”，确实比显式for短，但它并不一定比循环快。arrayfun本质上是把函数包装成逐元素调用，底层可能还是循环，而且还有额外函数调用开销。所以我的建议是：对性能有要求的时候，不要依赖arrayfun；对可读性有要求且数据量不大，可以偶尔使用。 同样的情况也适用于cellfun，它更适合cell数组。

6.4 什么时候必须保留for循环

既然向量化很香，那为什么还要学for循环？因为有些问题天然不适合向量化。

第一类是依赖前值的迭代公式，比如差分方程、递推滤波：

matlab复制x = zeros(1, 100);
x(1) = 1;
for k = 2:100
    x(k) = x(k-1) * 0.9 + randn;
end

这种场景用循环是正解。第二类是动态改变数据结构和伴随状态的情况，比如某个需要逐步更新的队列、树结构遍历。第三类是可读性优先的大型业务计算，强行向量化会让代码变得像天书，反而失去了维护价值。

7. 踩过的坑与调试技巧：索引错位、维度混乱、死循环

最后这部分，我把这些年在循环遍历矩阵时踩过的坑集中复盘一下，全是没有写在文档里的经验。

7.1 循环内修改循环变量并不“可控”

前面提过，MATLAB的for循环迭代次数在进入循环时就已经确定。如果你在循环体内修改i，下一次迭代仍会从预先确定的序列取值。我看过有人想模拟“跳过某些索引”而写i = i + 1，结果完全没效果。正确的做法是：

matlab复制for i = 1:10
    if i == 3
        continue; % 跳过本次
    end
    if i == 8
        break; % 跳出循环
    end
end

continue用于跳过，break用于终止，这是循环控制的正规军。

7.2 按行输出与按列输出导致的reshape陷阱

如果你用循环处理矩阵，最后想把结果排列成原矩阵形状，很容易在reshape时被列优先存储坑到。比如：

matlab复制A = [1 2 3; 4 5 6];
linear = 1:6;
B = reshape(linear, 2, 3);

B并不是[1 2 3;4 5 6]，而是[1 3 5;2 4 6]，因为reshape按列优先填充。如果你需要把行向量的结果还原成原矩阵结构，通常需要先填充一个列向量，再reshape，或者直接用B = zeros(size(A)); B(idx)=...按线性索引赋值。

7.3 维度搞混：size函数的两个输出顺序

size(A)返回[行数, 列数]，但在写[m,n] = size(A)时，很容易把m和n当成“高和宽”，在图像处理里又经常变成“宽和高”，到了三维视频数据还有人写成[w,h,c]。我的习惯是：

matlab复制[rows, cols] = size(A);

并且在写循环前先加一行注释，明确每个变量代表什么：

matlab复制% rows: 高度方向像素数
% cols: 宽度方向像素数

这个习惯能避免大量低级错误。

7.4 死循环排查经验

有时候你会在while循环里无限循环，但for循环也可能因为边界条件设置错误而“看似死循环”，比如索引溢出导致动态增长数组。遇到这种情况，我通常做三件事：

在循环体内添加早期提示，输出当前的循环变量。
把循环边界写成变量，用disp提前打印，确认范围。
对中间结果做断言断言：

matlab复制assert(k <= numel(A), 'k超出范围');

调完之后再删掉这些调试信息。

7.5 性能分析器的正确用法

不要靠猜来判断循环慢在哪里。MATLAB自带的profile和编辑器里的“运行并计时”按钮非常有用。比如你怀疑内存预分配有问题，可以先跑一遍分析，看哪一行耗时最高。我见过很多“优化半天结果白优化”的例子，就是因为没做profile，凭感觉去改。用profile定位瓶颈，再决定是向量化还是改遍历顺序，才能一针见血。

最后分享一个我自己的习惯：在写任何遍历矩阵的代码前，我会先在注释里写清楚“这个循环到底在遍历什么维度、每一步要做什么、结果存储在哪个位置”，然后才开始写。大多数矩阵遍历的Bug，都源于对维度和存储顺序的误解，而不是语法问题。这个习惯帮我省下了大量调试时间，也希望它能帮到你。