1-4-矩阵元素的引用

矩阵元素的引用

矩阵元素的引用方式

1. 通过下标来引用

   • A(3,2)表示A矩阵第3行第2列的元素

     A(3,2) = 200
     

   • 自动扩展

     >> A = [1,2,3;4,5,6]
     A =
         1     2     3
         4     5     6
     >> A(4,5) = 10
     A =
         1     2     3     0     0
         4     5     6     0     0
         0     0     0     0     0
         0     0     0     0    10
     

2. 通过序号来引用

   • 矩阵的序号与下标一一对应，以m×n矩阵A为例，矩阵元素A(i,j)的序号为(j-1)×m+j（下标横着数，序号竖着数）

     >> A = [1,2,3;4,5,6]
     A =
         1     2     3
         4     5     6
     >> A(4)
     ans =
         5
     

   • 序号和下标的转换

     • sub2ind函数：将矩阵中指定元素的行列下标转换成存储的序号

       • 格式：D = sub2ind(S,I,J)

         • D：序号
         • S：行和列组成的向量，可用size函数获取
         • I：转换矩阵元素的行下标
         • J：转换矩阵元素的列下标

         >> A = [11:13;15:17]
         A =
             11    12    13
             15    16    17
         >> D = sub2ind(size(A),[1,2;2,2],[1,1;3,2])
         %获取(1,1)、(2,1)、(2,3)、(2,2)的序号并组成矩阵赋值给D
         D =
             1     2
             6     4
         

     • ind2sub函数：将矩阵中指定元素的序号转换成行列下标

       • 格式：[I,J] = ind2sub(S,D)

         • I：行下标
         • J：列下标
         • S：行和列组成的向量，可用size函数获取
         • D：序号

         >> [I,J] = ind2sub([3,3],[1,3,5])
         %获取3x3矩阵中序号为1、3、5的行列下标
         I =
             1     3     2
         J =
             1     1     2
         %下标为(1,1)、(3,1)、(2,2)
         

利用冒号表达式获得子矩阵

A(i,:)          %第i行的全部元素
A(:,j)          %第j列的全部元素
A(i:i+m,k:k+m)  %第i~i+m行内且在第k~k+m列中的所有元素
A(i:i+m,:)      %第i~i+m行的全部元素

• end运算符：表示末尾元素的下标

利用空矩阵删除矩阵的元素

>> A = [1:4;5:8;9:12;13:16]
A =
    1     2     3     4
    5     6     7     8
    9    10    11    12
    13    14    15    16
>> A(:,2:3)=[]
A =
    1     4
    5     8
    9    12
    13    16

改变矩阵的形状

1. reshape函数：在矩阵元素不变的情况下，将矩阵A重新排成mxn的矩阵

   • 只改变原矩阵的行数和列数不改变原矩阵元素的个数和存储顺序
   • reshape(A,m,n)
     • A：原矩阵
     • m：行数
     • n：列数

   >> A = [1:4;5:8;9:12]
   A =
       1     2     3     4
       5     6     7     8
       9    10    11    12
   >> B = reshape(A,4,3)
   B =
       1     6    11
       5    10     4
       9     3     8
       2     7    12
   

2. A( : )：将矩阵A堆叠成一个列向量

   >> A = [1:3;4:6]
   A =
       1     2     3
       4     5     6
   >> B = A(:)
   B =
       1
       4
       2
       5
       3
       6