MATLAB数组的创建和使用（非常详细）

MATLAB 中的所有数据都按照数组的形式进行存储和运算，数组的属性及数组之间的逻辑关系是编写程序时非常重要的两方面。

在 MATLAB 中，数组的定义是广义的，数组元素可以为任意数据类型，如数值、字符串等。由于 MATLAB 面向对象的特性，数组成为 MATLAB 最重要的一种内置数据结构，而数组运算就是定义这种数据结构的方法。

本节系统地列出具备数组运算能力的函数名称，为兼顾一般性，以二维数组的运算为例，读者可推广至多维数组和多维矩阵的运算。下面介绍在 MATLAB 中如何创建数组，以及数组的常用操作等，包括数组的算术运算、关系运算和逻辑运算。

MATLAB数组的创建和操作

在 MATLAB 中，一般使用方括号“[]”、逗号“，”、空格和分号“；”来创建数组，数组中同一行的元素使用逗号或空格分隔，不同行之间用分号分隔。

【实例】创建空数组、行向量、列向量示例。在命令行窗口中输入以下语句，并显示相应的输出结果。

>> clear all
>> A = []
A =
    []

>> B = [6 5 4 3 2 1]
B =
    6     5     4     3     2     1

>> C = [6, 5, 4, 3, 2, 1]
C =
    6     5     4     3     2     1

>> D = [6; 5; 4; 3; 2; 1]
D =
    6
    5
    4
    3
    2
    1

>> E = B'  % 对 B 进行转置，得到列向量 E
E =
    6
    5
    4
    3
    2
    1

【实例】访问数组示例。在命令行窗口中输入以下语句，并显示相应的输出结果。

>> clear all
>> A = [6 5 4 3 2 1]
A =
    6     5     4     3     2     1

>> a1 = A(1)  % 访问数组中的第 1 个元素
a1 =
    6

>> a2 = A(1:3)  % 访问数组中的第 1、2、3 个元素
a2 =
    6     5     4

>> a3 = A(3:end)  % 访问数组中的第 3 个到最后一个元素
a3 =
    4     3     2     1

>> a4 = A(end:-1:1)  % 数组元素反序输出
a4 =
    1     2     3     4     5     6

>> a5 = A([1 6])  % 访问数组中的第 1 个及第 6 个元素
a5 =
    6     1

【实例】子数组的赋值示例。在命令行窗口中输入以下语句，并显示相应的输出结果。

>> clear all
>> A = [6 5 4 3 2 1]
A =
    6     5     4     3     2     1

>> A(3) = 0  % 将 A 中第 3 个位置上的元素设置为 0
A =
    6     5     0     3     2     1

>> A([1 4]) = [1 1]  % 将 A 中索引为 1 和 4 的位置上的元素分别设置为 1
A =
    1     5     0     1     2     1

在 MATLAB 中，还可以通过其他各种方式创建一维数组，具体如下所示。

1) 通过冒号创建一维数组

在 MATLAB 中，通过冒号创建一维数组的代码如下：

X = A:step:B

其中，A 是创建的一维数组的第一个变量，step 是每次递增或递减的数值，直到最后一个元素和 B 的差的绝对值小于或等于 step 的绝对值。

【实例】通过冒号创建一维数组示例。在命令行窗口中输入以下语句，并显示相应的输出结果。

>> clear all
>> A = 2:6  % 创建一个从 2 到 6 的整数序列，默认步长为 1
A =
    2     3     4     5     6

>> B = 2.1:1.5:6  % 创建一个从 2.1 开始，步长为 1.5，直到不超过 6 的序列
B =
    2.1000    3.6000    5.1000

>> C = 2.1:-1.5:-6  % 创建一个从 2.1 开始，步长为 -1.5，直到不小于 -6 的序列
C =
    2.1000    0.6000   -0.9000   -2.4000   -3.9000   -5.4000

>> D = 2.1:-1.5:6  % 创建一个从 2.1 开始，步长为 -1.5，直到不大于 6 的序列
D =
    空的 1×0 double 行向量

2) 通过logspace()函数创建一维数组

在 MATLAB 中，常用 logspace() 函数创建一维数组，其调用格式如下：

• y=logspace(a, b)：创建行向量 y，第一个元素为 10a，最后一个元素为 10b，形成含有 50 个元素的等比数列；
• y=logspace(a, b, n)：创建行向量 y，第一个元素为 10a，最后一个元素为 10b，形成含有 n 个元素的等比数列。

【实例】通过 logspace() 函数创建一维数组示例。在命令行窗口中输入以下语句，并显示相应的输出结果。

>> clear all
>> format short;  % 设置格式为短格式，即小数点后保留默认的 4 位
>> A = logspace(1,2,20)  % 创建一个包含 20 个对数间隔值的向量，第一个元素为 10^1，最后一个元素为 10^2
A =
    列 1 至 8
    10.0000    11.2884    12.7427    14.3845    16.2378    18.3298    20.6914    23.3572
    列 9 至 16
    26.3665    29.7635    33.5982    37.9269    42.8133    48.3293    54.5559    61.5848
    列 17 至 20
    69.5193    78.4760    88.5867   100.0000

>> B = logspace(1,2,10)  % 创建一个包含 10 个对数间隔值的向量，第一个元素为 10^1，最后一个元素为 10^2
B =
    列 1 至 8
    10.0000    12.9155    16.6810    21.5443    27.8256    35.9381    46.4159    59.9484
    列 9 至 10
    77.4264   100.0000

3) 通过linspace()函数创建一维数组

在 MATLAB 中，常用 linspace() 函数创建一维数组，其调用格式如下：

• y=linspace(a, b)：创建行向量 y，第一个元素为 a，最后一个元素为 b，形成含有 100 个元素的线性间隔向量；
• y=linspace(a, b, n)：创建行向量 y，第一个元素为 a，最后一个元素为 b，形成含有 n 个元素的线性间隔向量。

【实例】通过 linspace() 函数创建一维数组示例。在命令行窗口中输入以下语句。

>> clear all
>> format short;
>> A = linspace(1,100)
    % 创建一个包含默认数量（即 100 个）等间隔值的向量，起始值为 1，结束值为 100
A =
    列 1 至 15
    1     2     3     4     5     6     7     8     9    10    11    12    13    14    15
    列 16 至 30
    ...

    列 91 至 100
    91    92    93    94    95    96    97    98    99   100

>> B = linspace(1,36,12)
    % 创建一个包含 12 个等间隔值的向量，起始值为 1，结束值为 36
B =
    列 1 至 9
    1.0000    4.1818    7.3636   10.5455   13.7273   16.9091   20.0909   23.2727   26.4545
    列 10 至 12
    29.6364   32.8182   36.0000

>> C = linspace(1,36,1)
    % 创建一个包含 1 个等间隔值的向量，由于只有 1 个值，所以该向量实际上只包含 36
C =
    36

MATLAB数组的常见运算

1) 数组的算术运算

数组的运算是从数组的单个元素出发，针对每个元素进行的运算。在 MATLAB 中，一维数组的算术运算包括加、减、乘、左除、右除和乘方。

数组的加减运算：通过格式 A+B 或 A-B 可实现数组的加减运算。但是运算法则要求数组 A 和 B 的维数相同。

如果两个数组的维数不相同，则将给出错误提示信息。

【实例】数组的加减运算示例。在命令行窗口中输入以下语句，并显示相应的输出结果。

>> clear all
>> A = [1 5 6 8 9 6]
A =
    1     5     6     8     9     6
>> B = [9 85 6 2 4 0]
B =
    9    85     6     2     4     0
>> C = [1 1 1 1 1 1]
C =
    1     1     1     1     1     1
>> D = A+B  % 将向量 A 和 B 对应位置的元素相加得到向量 D
D =
    10    90    12    10    13     6
>> E = A-B  % 将向量 A 和 B 对应位置的元素相减得到向量 E
E =
    -8   -80     0     6     5     6
>> F = A*2  % 将向量 A 中的每个元素都乘以 2 得到向量 F
F =
    2    10    12    16    18    12
>> G = A+3  % 将向量 A 的每个元素都加上 3 得到向量 G
G =
    4     8     9    11    12     9
>> H = A-C  % 将向量 A 和 C 对应位置的元素相减得到向量 H
对于此运算，数组的大小不兼容。

数组的乘除运算：通过格式“.*”或“./”可实现数组的乘除运算。但是运算法则要求数组 A 和 B 的维数相同：

• 乘法：数组 A 和 B 的维数相同，运算为数组对应元素相乘，计算结果与 A 和 B 是相同维数的数组；
• 除法：数组 A 和 B 的维数相同，运算为数组对应元素相除，计算结果与 A 和 B 是相同维数的数组。
• 右除和左除的关系：A./B=B.\A，其中 A 是被除数，B 是除数。

如果两个数组的维数不相同，则将给出错误提示信息。

【实例】数组的乘法运算示例。在命令行窗口中输入以下语句，并显示相应的输出结果。

>> clear all
>> A = [1 5 6 8 9 6]
A =
    1     5     6     8     9     6
>> B = [9 5 6 2 4 0]
B =
    9     5     6     2     4     0
>> C = A .* B  % 数组的点乘，对 A 和 B 对应位置元素进行点乘（即对应位置相乘），得到 C
C =
    9    25    36    16    36     0
>> D = A * 3  % 数组与常数的乘法，将 A 中的每个元素都乘以 3 得到 D
D =
    3    15    18    24    27    18

【实例】数组的除法运算示例。在命令行窗口中输入以下语句，并显示相应的输出结果。

>> clear all
>> A = [1 5 6 8 9 6]
A =
    1     5     6     8     9     6
>> B = [9 5 6 2 4 0]
B =
    9     5     6     2     4     0
>> C = A.\B  % 数组和数组的左除，对 B 中的每个元素分别除以 A 中对应位置的元素，得到 C
C =
    9.0000    1.0000    1.0000    0.2500    0.4444    0

>> D = A./B  % 数组和数组的右除，对 A 中的每个元素分别除以 B 中对应位置的元素，得到 D
D =
    0.1111    1.0000    1.0000    4.0000    2.2500    Inf

>> E = A./3  % 数组与常数的除法，将 A 中的每个元素都除以 3 得到 E
E =
    0.3333    1.6667    2.0000    2.6667    3.0000    2.0000

>> F = A/3  % 将 A 中的每个元素除以 3 得到 F，是每个元素除以 3 后的值
F =
    0.3333    1.6667    2.0000    2.6667    3.0000    2.0000

通过乘方格式“.^”实现数组的乘方运算。数组的乘方运算包括数组间的乘方运算、数组与某个具体数值的乘方运算，以及常数与数组的乘方运算。

【实例】数组的乘方运算示例。在命令行窗口中输入以下语句，并显示相应的输出结果。

>> clear all
>> A = [1 5 6 8 9 6]
A =
    1     5     6     8     9     6
>> B = [9 5 6 2 4 0]
B =
    9     5     6     2     4     0
>> C = A.^B  % 数组的乘方，将 A 中的每个元素分别与 B 中对应位置的元素相乘方，得到 C
C =
    1    3125    46656    64    6561     1
>> D = A.^3  % 数组与某个具体数值的乘方，将 A 中的每个元素分别乘以自身的三次方，得到 D
D =
    1    125    216    512    729    216
>> E = 3.^A  % 常数与数组的乘方，将常数 3 分别与 A 中的每个元素相乘方，得到 E
E =
    3    243    729    6561   19683   729

通过使用函数 dot() 可实现数组的点积运算，但是运算法则要求数组 A 和 B 的维数相同，其调用格式如下。

• C=dot(A, B)：返回 A 和 B 的标量点积。A 和 B 为向量时长度必须相同；为矩阵或多维数组时，大小必须相同；
• C=dot(A, B, dim)：计算 A 和 B 沿维度 dim 的点积。dim 是一个正整数标量。

【实例】数组的点积运算示例。在命令行窗口中输入以下语句，并显示相应的输出结果。

>> clear all
>> A = [1 5 6 8 9 6]
A =
    1     5     6     8     9     6
>> B = [9 5 6 2 4 0]
B =
    9     5     6     2     4     0
>> C = dot(A,B)  % 数组的点积，即将 A 和 B 对应位置元素相乘后再相加得到标量 C
C =
    122

2) 数组的关系运算

在 MATLAB 中，提供了 6 种数组关系运算符，即 ＜（小于）、＜=（小于或等于）、＞（大于）、＞=（大于或等于）、==（恒等于）、～=（不等于）。关系运算的运算法则如下：

• 当两个比较量是标量时，直接比较两个数的大小。若关系成立，则返回的结果为 1；否则为 0。
• 当两个比较量是维数相等的数组时，逐一比较两个数组相同位置的元素，并给出比较结果。最终的关系运算结果是一个与参与比较的数组维数相同的数组，其组成元素为 0 或 1。

【实例】数组的关系运算示例。在命令行窗口中输入以下语句，并显示相应的输出结果。

>> clear all
>> A = [1 5 6 8 9 6]
A =
    1     5     6     8     9     6
>> B = [9 5 6 2 4 0]
B =
    9     5     6     2     4     0
>> C = A<6  % 数组与常数比较，小于
C =
    1×6 logical 数组
    1     1     0     0     0     0
>> D = A>=6  % 数组与常数比较，大于或等于
D =
    1×6 logical 数组
    0     0     1     1     1     1
>> E = A<B  % 数组与数组比较，小于
E =
    1×6 logical 数组
    0     1     0     0     0     0
>> F = A==B  % 数组与数组比较，恒等于
F =
    1×6 logical 数组
    0     1     1     0     0     0

3) 数组的逻辑运算

在 MATLAB 中，提供了 3 种数组逻辑运算符，即 &（与）、|（或）和～（非）。逻辑运算的运算法则如下：

• 如果是非零元素，则为真，用1表示；如果是零元素，则为假，用 0 表示；
• 当两个比较量是维数相同的数组时，逐一比较两个数组相同位置上的元素，并给出比较结果。最终的逻辑运算结果是一个与参与比较的数组维数相同的数组，其组成元素为 0 或 1；
• 在进行与运算（a&b）时，a、b 全为非零，则为真，运算结果为 1。在进行或运算（a|b）时，只要 a、b 有一个非零，则运算结果为 1。在进行非运算（～a）时，若 a 为 0，则运算结果为 1；若 a 非零，则运算结果为 0。

【实例】数组的逻辑运算示例。在命令行窗口中输入以下语句，并显示相应的输出结果。

>> clear all
>> A = [1 5 6 8 9 6]
A =
    1     5     6     8     9     6
>> B = [9 5 6 2 4 0]
B =
    9     5     6     2     4     0
>> C = A&B  % 与运算
C =
    1×6 logical 数组
    1     1     1     0     1     0
>> D = A|B  % 或运算
D =
    1×6 logical 数组
    1     1     1     1     1     1
>> E = ~B  % 非运算
E =
    1×6 logical 数组
    0     0     0     1     0     1