本页翻译不是最新的。点击此处可查看最新英文版本。

union

设置两个数组的并集

语法

C = union(A,B)

C = union(A,B,setOrder)

C = union(A,B,___,'rows')

C = union(A,B,'rows',___)

[C,ia,ib] = union(___)

[C,ia,ib] = union(A,B,'legacy')

[C,ia,ib] = union(A,B,'rows','legacy')

说明

C = union(A,B) 返回 A 和 B 的合并数据，但是不包含重复项。C 已排序。

• 如果 A 和 B 是表或时间表，union 将返回这两个表的行的并集。对于时间表，union 在确定相等性时会考虑行时间，并按行时间对输出时间表 C 进行排序。

C = union(A,B,setOrder) 以特定顺序返回 C。setOrder 可以是 'sorted' 或 'stable'。

C = union(A,B,___,'rows') 和 C = union(A,B,'rows',___) 将 A 和 B 中的每一行视为单个实体，并返回 A 和 B 中的行的并集，不包含重复项。必须指定 A 和 B，setOrder 是可选的。

'rows' 选项不支持元胞数组，除非其中一个输入项为分类数组或日期时间数组。

[C,ia,ib] = union(___) 支持任何上述语法，且可返回索引向量 ia 和 ib。

• 一般情况下，C 中的值是 A(ia) 和 B(ib) 的元素的有序并集。

• 如果指定了 'rows' 选项，则 C 中的行是 A(ia,:) 和 B(ib,:) 的行的有序并集。

• 如果 A 和 B 是表或时间表，则 C 是 A(ia,:) 和 B(ib,:) 的行的有序并集。

[C,ia,ib] = union(A,B,'legacy') 和 [C,ia,ib] = union(A,B,'rows','legacy') 保留 R2012b 和早期版本中 union 函数的行为。

'legacy' 选项不支持分类数组、日期时间数组、持续时间数组、表或时间表。

示例

两个向量的并集

定义都包含某个值的两个向量。

A = [5 7 1]; 
B = [3 1 1];

计算向量 A 和 B 的并集。

C = union(A,B)

C = 1×4

     1     3     5     7

两个表的并集

定义都包含某些行的两个表。

A = table([1:5]',['A';'B';'C';'D';'E'],logical([0;1;0;1;0]))

A=5×3 table
    Var1    Var2    Var3 
    ____    ____    _____

     1       A      false
     2       B      true 
     3       C      false
     4       D      true 
     5       E      false

B = table([1:2:10]',['A';'C';'E';'G';'I'],logical(zeros(5,1)))

B=5×3 table
    Var1    Var2    Var3 
    ____    ____    _____

     1       A      false
     3       C      false
     5       E      false
     7       G      false
     9       I      false

计算表 A 和 B 的并集。

C = union(A,B)

C=7×3 table
    Var1    Var2    Var3 
    ____    ____    _____

     1       A      false
     2       B      true 
     3       C      false
     4       D      true 
     5       E      false
     7       G      false
     9       I      false

两个向量及其索引的并集

定义都包含某个值的两个向量。

A = [5 7 1]; 
B = [3 1 1];

计算向量 A 和 B 以及索引向量 ia 和 ib 的并集。

[C,ia,ib] = union(A,B)

C = 1×4

     1     3     5     7

ia = 3×1

     3
     1
     2

ib = 1

C 中的值是 A(ia) 和 B(ib) 的合并值。

两个表及其索引的并集

定义表 A，其中包含三个人的性别、年龄和身高。

A = table(['M';'M';'F'],[27;52;31],[74;68;64],...
'VariableNames',{'Gender' 'Age' 'Height'},...
'RowNames',{'Ted' 'Fred' 'Betty'})

A=3×3 table
             Gender    Age    Height
             ______    ___    ______

    Ted        M       27       74  
    Fred       M       52       68  
    Betty      F       31       64  

定义表 B，所含变量与 A 相同。

B = table(['F';'M'],[64;68],[31;47],...
'VariableNames',{'Gender' 'Height' 'Age'},...
'RowNames',{'Meg' 'Joe'})

B=2×3 table
           Gender    Height    Age
           ______    ______    ___

    Meg      F         64      31 
    Joe      M         68      47 

计算表 A 和 B 以及索引向量 ia 和 ib 的并集。

[C,ia,ib] = union(A,B)

C=4×3 table
             Gender    Age    Height
             ______    ___    ______

    Betty      F       31       64  
    Ted        M       27       74  
    Joe        M       47       68  
    Fred       M       52       68  

ia = 3×1

     3
     1
     2

ib = 2

Meg 与 Betty 的数据相同。union 仅返回 A 的索引，与 Betty 对应。

两个矩阵中的行的并集

定义都包含某行的两个矩阵。

A = [2 2 2; 0 0 1];
B = [1 2 3; 2 2 2; 2 2 2];

计算没有重复项的 A 和 B 的合并行，以及索引向量 ia 和 ib 的合并行。

[C,ia,ib] = union(A,B,'rows')

C = 3×3

     0     0     1
     1     2     3
     2     2     2

ia = 2×1

     2
     1

ib = 1

C 的行是 A(ia,:) 和 B(ib,:) 的合并行。

具有指定输出顺序的两个向量的并集

使用 setOrder 参量指定 C 中值的排序方式。

如果您想要 C 中的值与 A 和 B 中的值顺序相同，请指定 'stable'。

A = [5 7 1]; 
B = [3 1 1];
[C,ia,ib] = union(A,B,'stable')

C = 1×4

     5     7     1     3

ia = 3×1

     1
     2
     3

ib = 1

此外，还可以指定 'sorted' 顺序。

A = [5 7 1]; 
B = [3 1 1];
[C,ia,ib] = union(A,B,'sorted')

C = 1×4

     1     3     5     7

ia = 3×1

     3
     1
     2

ib = 1

包含 NaN 的向量的并集

定义两个包含 NaN 的向量。

A = [5 NaN 1]; 
B = [4 NaN NaN];

计算向量 A 和 B 的并集。

C = union(A,B)

C = 1×6

     1     4     5   NaN   NaN   NaN

union 将 NaN 值视为不同的值。

带有尾随空白的字符向量元胞数组

创建字符向量元胞数组 A。

A = {'dog','cat','fish','horse'};

创建字符向量元胞数组 B，其中某些向量带有尾随空白。

B = {'dog ','cat','fish ','horse'};

合并 A 和 B 的元素。

[C,ia,ib] = union(A,B)

C = 1x6 cell
    {'cat'}    {'dog'}    {'dog '}    {'fish'}    {'fish '}    {'horse'}

ia = 4×1

     2
     1
     3
     4

ib = 2×1

     1
     3

union 将字符向量元胞数组中的尾随空白视为不同的字符。

具有不同类和形状的向量的并集

创建一个列向量字符数组。

A = ['A';'B';'C']

A = 3x1 char array
    'A'
    'B'
    'C'

class(A)

ans = 
'char'

创建一个包含数值类型 double 的元素的行向量。

B = [68 69 70]

B = 1×3

    68    69    70

class(B)

ans = 
'double'

A 和 B 的 union 返回一个列向量字符数组。

C = union(A,B)

C = 6x1 char array
    'A'
    'B'
    'C'
    'D'
    'E'
    'F'

class(C)

ans = 
'char'

字符和字符向量元胞数组的并集

创建一个包含字母 a、b 和 c 的字符向量。

A = ['a';'b';'c'];
class(A)

ans = 
'char'

创建一个包含字母 c、d 和 e 的字符向量元胞数组。

B = {'c','d','e'};
class(B)

ans = 
'cell'

合并 A 和 B 的元素。

C = union(A,B)

C = 5x1 cell
    {'a'}
    {'b'}
    {'c'}
    {'d'}
    {'e'}

结果 C 是字符向量元胞数组。

class(C)

ans = 
'cell'

保留并集的旧版行为

在代码中使用 'legacy' 标志以保留 R2012b 和早期版本中 union 的行为。

计算 A 和 B 的并集并保留当前行为。

A = [5 7 1]; 
B = [3 1 1];
[C1,ia1,ib1] = union(A,B)

C1 = 1×4

     1     3     5     7

ia1 = 3×1

     3
     1
     2

ib1 = 1

计算 A 和 B 的并集并保留旧版行为。

A = [5 7 1]; 
B = [3 1 1];
[C2,ia2,ib2] = union(A,B,'legacy')

C2 = 1×4

     1     3     5     7

ia2 = 1×2

     1     2

ib2 = 1×2

     3     1

输入参数

A,B — 输入数组

数组

输入数组。如果指定 'rows' 选项，则 A 和 B 的列数必须相同。

A 和 B 必须是相同类，以下情况例外：

• logical、char 和所有数值类可以与 double 数组合并。

• 字符向量元胞数组可与字符数组或字符串数组合并。

• 分类数组可与字符数组、字符向量元胞数组或字符串数组合并。

• 日期时间数组可与日期字符向量元胞数组或单个日期字符向量合并。

根据数据类型，对 A 和 B 还有其他要求：

• 如果 A 和 B 均为有序分类数组，则必须具有相同的类别集（包括其顺序）。如果 A 和 B 都不是有序分类数组，则不必具有相同的类别集，因此可使用类别名称对两者进行比较。在这种情况下，C 的类别中前面是 A 的类别，后面跟有不在 A 中的 B 的类别。类别的顺序与在 A 和 B 中的顺序相同，将使用类别顺序对 C 进行排序。

• 如果 A 和 B 是表或时间表，则必须具有相同的变量名称（顺序除外）。对于表，将忽略行名称，所以值相同而名称不同的两行将被视为相等。对于时间表，将考虑行时间，所以值相同而时间不同的两行将被视为不相等。

• 如果 A 和 B 是日期时间数组，则它们在是否指定时区方面彼此之间必须一致。

A 和 B 还可以是具有以下类方法的对象：

• sort（或 'rows' 选项的 sortrows）

• ne

对象类方法彼此之间必须一致。这些对象包括从相同根类导出的异构数组。例如，A 和 B 可以是图形对象的句柄数组。

setOrder — 顺序标志

'sorted' (默认) | 'stable'

顺序标志以 'sorted' 或 'stable' 指定，指示 C 中值（或行）的顺序。

标志	描述
'sorted'	按 sort 返回的排序顺序返回 C 中的值（或行）。 示例 C = union([5 5 3],[1 2 5],'sorted') C = 1 2 3 5
'stable'	C 中的值（或行）按它们在 A 中的显示顺序返回，然后按它们在 B 中的显示顺序返回。 示例 C = union([5 5 3],[1 2 5],'stable') C = 5 3 1 2

数据类型: char | string

输出参量

C — A 和 B 的合并数据

向量 | 矩阵 | 表 | 时间表

A 和 B 的合并数据，以向量、矩阵、表或时间表形式返回。如果输入 A 和 B 是表或时间表，则 C 中的变量顺序与 A 中的变量顺序相同。

下面介绍了当输入为向量或矩阵并且未指定 'legacy' 标志时 C 的形状：

• 如果未指定 'rows' 标志，则 C 为列向量，除非 A 和 B 都是行向量，在这种情况下，C 为行向量。例如，union([],[1 2]) 返回一个列向量。

• 如果指定了 'rows' 标志，则 C 是一个包含 A 和 B 的合并行的矩阵。

输入 A 和 B 的类确定 C 的类：

• 如果 A 和 B 的类相同，则 C 为相同类。

• 如果将 char 或非双精度数值类与 double 合并，则 C 是与非双精度输入相同的类。

• 如果将 logical 类与 double 合并，则 C 是 double。

• 如果将字符向量元胞数组与 char 合并，则 C 是字符向量元胞数组。

• 如果将分类数组与字符向量、字符向量元胞数组或字符串合并，则 C 是分类数组。

• 如果将日期时间数组与日期字符向量元胞数组或单个日期字符向量合并，则 C 是日期时间数组。

• 如果将字符串数组与字符向量或字符向量元胞数组合并，则 C 是字符串数组。

ia — A 的索引

列向量

A 的索引，当未指定 'legacy' 标志时以列向量的形式返回。ia 指示 A 中合入并集中的值（或行）。如果某个值（或行）在 A 中出现多次，则 ia 将包含值（或行）第一次出现位置的索引。如果某个值同时出现在 A 和 B 中，则 ia 包含 A 中第一次出现位置的索引。

ib — B 的索引

列向量

B 的索引，当未指定 'legacy' 标志时以列向量的形式返回。ib 指示 B 中合入并集中的值（或行）。如果有仅在 B 中重复出现的值（或行），则 ib 包含该值第一次出现位置的索引。如果某个值（或行）同时出现在 A 和 B 中，则 ib 不包含该值（或行）的索引。

提示

• 要计算与一个表或时间表的变量子集相关的并集，可以使用列下标。例如，可以使用 union(A(:,vars),B(:,vars))，其中 vars 为正整数、正整数向量、变量名称、变量名称元胞数组或逻辑向量。您也可以使用 vartype 创建一个下标，以选择指定类型的变量。

扩展功能

tall 数组

对行数太多而无法放入内存的数组进行计算。

用法说明和限制：

• 不支持 'stable' 排序顺序。

• 不支持 'legacy' 标志。

• 不支持 char 类型的输入。

有关详细信息，请参阅 tall 数组。

C/C++ 代码生成

使用 MATLAB® Coder™ 生成 C 代码和 C++ 代码。

用法说明和限制：

• 代码生成不支持对第一个或第二个参量使用元胞数组。

• 代码生成不支持在可变大小的行和列之间使用 union。A 和 B 必须为具有相同方向的可变大小向量输入。

• 如果不指定 'rows' 选项：

  • 输入 A 和 B 必须为方向相同的向量。如果指定 'legacy' 选项，则输入 A 和 B 必须为行向量。

  • 可变大小行向量的第一个维度必须具有固定长度 1。可变大小列向量的第二个维度必须具有固定长度 1。

  • 不支持输入 []。使用 1×0 或 0×1 输入（例如 zeros(1,0)）表示空集。

  • 如果指定 'legacy' 选项，则空输出为行向量 1×0，永远不会是 0×0。

• 如果同时指定 'legacy' 和 'rows' 选项，则输出 ia 和 ib 为列向量。如果这些输出为空，则它们是 0×1，永远不会是 0×0，即使输出 C 为 0×0 也是如此。

• 当 setOrder 不是 'stable' 或当您指定 'legacy' 选项时，输入必须已按升序进行排序。第一个输出 C 按升序排序。

• 复数输入必须为 single 或 double。

• 如果一个输入为复数，另一个输入为实数，请执行以下操作之一：

  • 将 setOrder 设置为 'stable'。

  • 按复数升序（按绝对值）对实数输入进行排序。假设实数输入为 x。使用 sort(complex(x)) 或 sortrows(complex(x))。

• 请参阅具有零值虚部的复数数据的代码生成 (MATLAB Coder)。

基于线程的环境
使用 MATLAB® backgroundPool 在后台运行代码或使用 Parallel Computing Toolbox™ ThreadPool 加快代码运行速度。

GPU 数组

通过使用 Parallel Computing Toolbox™ 在图形处理单元 (GPU) 上运行来加快代码执行。

union 函数部分支持 GPU 数组。当您将输入数据指定为 gpuArray (Parallel Computing Toolbox) 时，函数的某些语法可在 GPU 上运行。用法说明和限制：

• 不支持 'legacy' 标志。

• 不支持 64 位整数。

有关详细信息，请参阅Run MATLAB Functions on a GPU (Parallel Computing Toolbox)。

分布式数组

使用 Parallel Computing Toolbox™ 在集群的组合内存中对大型数组进行分区。

用法说明和限制：

• 不支持 'legacy' 标志。

• 不支持表、时间表、分类、日期时间和持续时间输入。

• 当 A 或 B 是字符向量元胞数组时，类型为 char 和 string 的输入不受支持。改为将字符向量输入参量的元胞数组转换为字符串数组。

有关详细信息，请参阅Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox)。

版本历史记录

在 R2006a 之前推出

另请参阅

unique | intersect | ismember | issorted | setdiff | setxor | sort

主题

• 合并分类数组