MATLAB程序设计与应用 4.2 程序控制结构

MATLAB程序设计与应用

4. 第4章 MATLAB程序流程控制

4.2 程序控制结构

程序的控制结构有3种:顺序结构、选择结构和循环结构。任何复杂的程序都可以由这3种基本结构构成。MATLAB提供了实现控制结构的语句，利用这些语句可以编写解决特定问题的程序。

4.2.1 顺序结构

顺序结构是指按照程序中语句的排列顺序依次执行，直到程序的最后一个语句为止。这是最简单的一种程序结构。
学习程序设计，首先从顺序结构开始。程序实现通常包括数据输入、数据处理和数据输出3个操作步骤，其中输入输出反映了程序的交互性，一般是一个程序必需的步骤，而数据处理是指要进行的操作与运算，根据解决的问题不同而需要使用不同的语句来实现。

1. 数据的输入

   在程序中如果需要从键盘输入数据，可以使用input函数来实现，其调用格式如下:

   A = input(提示信息);
   1

   其中,“提示信息”为一个字符串，用于提示用户输入什么样的数据。例如,
   从键盘输入A矩阵,可以采用下面的语句来完成：

   A = input('输入A矩阵：');
   1

   执行该语句时，首先在屏幕上显示提示信息“输入A矩阵:”,然后等待用户从键盘按MATLAB规定的格式输入A矩阵的值。

   如果要输入一个字符串，则字符串前后要加单引号,以界定字符串的开始与结束。

   

   如果要输入一个字符串,也可以在调用input 函数时使用’s’选项。

   

   这个样子输入的时候就不用加引号了。

2. 数据的输出

   MATLAB提供的输出函数主要有 disp函数，其调用格式如下:

   disp(输出项)
   1

   其中，输出项既可以是字符串，也可以是矩阵。

   >> A = 'Hello,world!';
   >> disp(A)
   Hello,world!
   >> A = [1,2,3;4,5,6;7,8,9];
   >> disp(A)
        1     2     3
        4     5     6
        7     8     9
   1
   2
   3
   4
   5
   6
   7
   8

   注意:和前面介绍的矩阵显示方式不同,用disp函数显示矩阵时将不显示矩阵的名字,而且其输出格式更紧凑，不留任何没有意义的空行。

   示例——求一元二次方程ax^2 + bx + c = 0的根

   a = input('a=?');
   b = input('b=?');
   c = input('c=?');
   
   d = b * b - 4 * a * c;
   
   x = [(-b + sqrt(d)) / (2 * a),(-b - sqrt(d)) / (2 * a)];
   
   disp(['x1=',num2str(x(1)),' x2=',num2str(x(2))]);
   1
   2
   3
   4
   5
   6
   7
   8
   9

   运行exam1.m

   >> exam1
   a=?4
   b=?78
   c=?54
   x1=-0.7188 x2=-18.7812
   1
   2
   3
   4
   5

   

3. 程序的暂停

   当程序运行时，为了查看程序的中间结果或者观看输出的图形，有时需要暂停程序的执行。这时可以使用 pause函数,其调用格式如下:

   pause(延迟秒数)
   1

   如果省略延迟时间，直接使用pause,则将暂停程序,直到用户按任一键后程序继续执行。若在程序的执行过程中要强行中止程序的运行可按 Ctrl+C键。

4.2.2 选择结构

选择结构又称为分支结构，它根据给定的条件是否成立，决定程序的运行路线，在不同的条件下,执行不同的操作。MATLAB用于实现选择结构的语句有if语句、switch 语句和try语句。

1. if语句

   在 MATLAB中，if语句有以下3种格式。

   • 单分支if

     if 条件
     	语句组
     end
     1
     2
     3

     其中，条件一般用关系运算或逻辑运算来表示,其结果是一个标量或矩阵。当结果矩阵非空,且不包含零元素时，该条件成立，否则不成立。例如，当条件为[1,2;3,4]时，判定条件成立;当条件为或[1, 2;0,4]时，判定条件不成立。MATLAB 中建议条件尽量使用标量，条件的结果为非零时，表示条件成立，零表示条件不成立。当对标量进行逻辑与运算或者逻辑或运算时，其运算符可以采用&&和||。
     当条件成立时,则执行语句组，执行完之后继续执行if语句后面的语句，若条件不成立,则直接执行if语句后面的语句。例如，当x是整数矩阵时，输出x的值，语句如下:

     if fix(x) == x:
     	disp(x);
     end
     1
     2
     3

   • 双分支if

     if 条件
     	语句组1
     else
     	语句组2
     end
     1
     2
     3
     4
     5

     当条件成立时，执行语句组1，否则执行语句组2，语句组1或语句组2执行后，再执行if语句后面的语句。

     示例：计算分段函数的值

     

     x = input('请输入x的值：');
     
     if x == 10
         y = cos(x + 1) + sqrt(x * x + 1);
     else
         y = x * sqrt(x + sqrt(x));
     end
     y
     1
     2
     3
     4
     5
     6
     7
     8

     >> exam2
     请输入x的值：10
     
     y =
     
        10.0543
     
     >> exam2
     请输入x的值：11
     
     y =
     
        41.6210
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12
     13

   • 多分支if语句

     if 条件
     	语句组1
     elseif 条件2
     	语句组2
     	...
     elseif 条件m
     	语句组m
     else
     	语句组n
     end
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10

     示例：输入一个字符，若为大写字母，则输出其对应的小写字母;若为小写字母，则输出其对应的大写字母;若为数字字符则输出其对应数的平方，若为其他字符则原样输出。

     c = input('请输入一个字符：','s');
     
     if c >= 'A' && c <= 'Z'
         disp(lower(c));
     
     elseif c >= 'a' && c <= 'z'
         disp(upper(c));
     
     elseif c >= '0' && c <= '9'
         disp(str2double(c) ^ 2);
     else
         disp(c);
     end
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12
     13

     >> exam1
     请输入一个字符：R
     r
     >> exam1
     请输入一个字符：b
     B
     >> exam1
     请输入一个字符：7
         49
     1
     2
     3
     4
     5
     6
     7
     8
     9

2. switch语句

   switch语句根据表达式的取值不同，分别执行不同的语句，其语句格式如下

   switch 表达式
   	case 结果表1
   		语句组1
   	case 结果表2
   		语句组2
   	...
   	case 结果表m
   		语句组m
   	otherwise
   		语句组n
   end
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11

   switch子句后面的表达式应为一个标量或一个字符串，case子句后面的结果不仅可以为一个标量或一个字符串，还可以为一个将多个结果用大括号括起来的里元数据。如果casE 于可后面的结果表为一个单元数据，则表达式的值等于该单元数据中的某个元素时，执行相应的语句组。

   示例

   某商场对商品实行打折销售，标准如下(商品价格用price来表示)。

   price < 200            没有折扣
   200 <= price < 500     3%折扣
   500 <= price < 1000    5%折扣
   1000 <= price < 2500   8%折扣
   2500 <= price < 5000   10%折扣
   5000 <= price          14%折扣
   1
   2
   3
   4
   5
   6

   输入所售商品的价格，求其实际销售价格。

   price = input('请输入商品价格');
   
   switch fix(price / 100)
       case {0,1}
           rate = 0;
       case {2,3,4}
           rate = 3 / 100;
       case num2cell(5:9)
           rate = 5 / 100;
       case num2cell(10:24)
           rate = 8 / 100;
       case num2cell(25:49)
           rate = 10 / 100;
       otherwise
           rate = 14 / 100;
   end
   price =  price * (1 - rate)
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17

   >> exam2
   请输入商品价格2000
   
   price =
   
           1840
   1
   2
   3
   4
   5
   6

3. try语句

   try语句是一种试探性执行语句,为开发人员提供了一种捕获错误的机制,其语句格式如下

   try 
   	语句组1
   catch 
   	语句组2
   end
   1
   2
   3
   4
   5

   try语句先试探性执行语句组1，如果语句组1在执行过程中出现错误，则将错误信息赋给预定义变量 lasterr,并转去执行语句组2。如果不出错，则转去执行end后面的语句。

   示例：矩阵乘法运算要求两矩阵的维数相容，否则会出错。先求两矩阵的乘积，若出错，则提示错误信息。

   A = input('请输入A矩阵');
   B = input('请输入B矩阵');
   
   
   try
       C = A * B
   catch
       lasterr
   end
   1
   2
   3
   4
   5
   6
   7
   8
   9

   >> exam3
   请输入A矩阵[1,2,3;4,5,6]
   请输入B矩阵[1,2;3,4;5,6]
   
   C =
   
       22    28
       49    64
   
   >> exam3
   请输入A矩阵[1,2,3;4,5,6]
   请输入B矩阵[7,8,9;10,11,12]
   
   ans =
   
       '错误使用  * 
        用于矩阵乘法的维度不正确。请检查并确保第一个矩阵中的列数与第二个矩阵中的行数匹配。要单独对矩阵的每个元素进行运算，请使用 TIMES (.*)执行按元素相乘。'
   
   >> 
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19

4.2.3 循环结构

循环结构的基本思想是重复，即利用计算机运算速度快以及能进行逻辑控制的特点，重复执行某些语句，以满足大量的计算要求。虽然每次循环执行的语句相同，但语句中一些变量的值是变化的，而且当循环到一定次数或满足条件后能结束循环。循环是计算机解题的一个重要特征，也是程序设计的一种重要技巧。MATLAB 提供了两种实现循环结构的语句: for语句和while语句。

1. for语句

   一般情况下，对于事先能确定循环次数的循环结构，使用for语句是比较方便的。

   for 循环变量 = 表达式1:表达式2:表达式3
   	循环体语句
   end
   1
   2
   3

   其中，“表达式1:表达式2:表达式3”是一个冒号表达式，将产生一个行向量，3个表达式分别代表初值、步长和终值。步长为1时，表达式2可以省略。

   (1) for语句针对向量的每一个元素执行一次循环体，循环的次数就是向量中元素的个数，也可以针对任意向量

   (2）可以在 for 循环体中修改循环变量的值，但当程序执行流程再次回到循环开始时，就会自动被设成向量的下一个元素。

   (3) for语句中的3个表达式只在循环开始时计算一次，也就是说，向量元素一旦确定将不会再改变。如果在表达式中含有变量，即便在循环体中改变变量的值，向量的元素也不改变。

   (4)退出循环之后,循环变量的值就是向量中最后的元素值。

   (5)当向量为空时，循环体一次也不执行。

   示例——水仙花

   shu = [];
   for m = 100:999
       m1 = fix(m / 100);
       m2 = rem(fix(m / 10) , 10);
       m3 = rem(m , 10);
   
       if m == m1 * m1 * m1 + m2 * m2 * m2 + m3 * m3 * m3
           shu = [shu,m];
       end
   end
   
   disp(shu)
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12

   >> exam4
      153   370   371   407
   1
   2

   示例2

   

   y = 0;
   n = 100;
   
   for i = 1 : n
       y = y + 1 / (i * i);
   end
   y
   1
   2
   3
   4
   5
   6
   7

   >> exam5
   
   y =
   
       1.6350
   1
   2
   3
   4
   5

   示例

   

   a = 0;
   b = 3 * pi;
   n = 1000;
   h = (b - a) / n;
   x = a;
   s = 0;
   
   f0 = exp(-0.5 * x) * sin(x + pi / 6);
   
   for i = 1 : n
       x = x + h;
       f1 = exp(-0.5 * x) * sin(x + pi / 6);
       s = s + (f0 + f1) * h / 2;
       f0 = f1;
   end
   s
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16

   >> exam6
   
   s =
   
       0.9008
   1
   2
   3
   4
   5

2. while语句

   while 语句就是通过判断循环条件是否满足来决定是否继续循环的一种循环控制语句，也称为条件循环语句。它的特点是先判断循环条件，条件满足时执行循环。while语句的一般格式如下:

   while 条件
   	循环体语句
   end
   1
   2
   3

   示例

   从键盘输入若干个数，当输入0时结束输入，求这些数的平均值和它们之和。

   sum = 0;
   n = 0;
   
   x = input('Enter a number (end in 0)：');
   
   while x ~= 0
       sum = sum + x;
       n = n + 1;
       x = input('Enter a number (end in 0)：');
   
   end
   
   if n > 0
       sum
       mean = sum / n
   end
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16

   >> exam7
   Enter a number (end in 0)：67
   Enter a number (end in 0)：89
   Enter a number (end in 0)：93
   Enter a number (end in 0)：70
   Enter a number (end in 0)：0
   
   sum =
   
      319
   
   
   mean =
   
      79.7500
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15

   示例——根据矩阵指数的幂级数展开式求矩阵指数。

   

   设X是给定的矩阵,E是矩阵指数函数值,F是展开式的项，n是项数，循环一直进行到F很小，以至于F值加在E上对E的值影响不大时为止。为了判断F是否很小,可利用求矩阵范数的函数norm(F,1)来计算。所以当norm(F,1)=0时，认为F很小，应退出循环的执行。

   X = input('Enter X：');
   
   E = zeros(size(X));
   
   F = eye(size(X));
   
   n = 1;
   
   while norm(F , 1) > 0
       E = E + F;
       F = F * X / n;
       n = n + 1;
   end
   E
   expm(X)
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15

   >> exam8
   Enter X：[0.5,2,0;1,-1,-0.5;0.9,1,0.75]
   
   E =
   
       2.6126    2.0579   -0.6376
       0.7420    0.7504   -0.5942
       2.5678    2.3359    1.5549
   
   
   ans =
   
       2.6126    2.0579   -0.6376
       0.7420    0.7504   -0.5942
       2.5678    2.3359    1.5549
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15

3. break语句和continue语句

   与循环结构相关的语句还有 break语句和continue语句,它们一般与if语句配合使用。break语句用于终止循环的执行。当在循环体内执行到该语句时，程序将跳出循环，继续执行循环语句的下一语句。
   continue语句控制跳过循环体中的某些语句。当在循环体内执行到该语句时，程序将跳过循环体中所有剩下的语句，继续下一次循环。

   示例——求[100,200]之间第一个能被21整除的整数。

   for n = 100 : 200
       if rem(n , 21) ~= 0
           continue
       end
       n
       break
   end
   1
   2
   3
   4
   5
   6
   7

   >> exam9
   
   n =
   
      105
   1
   2
   3
   4
   5

4. 循环的嵌套

   如果一个循环结构的循环体又包括一个循环结构，就称为循环的嵌套，或称为多重循环结构。实现多重循环结构仍用前面介绍的循环语句。因为任一循环语句的循环体部分都可以包含另一个循环语句，这种循环语句的嵌套为实现多重循环提供了方便。
   多重循环的嵌套层数可以是任意的，可以按照嵌套层数，分别叫做二重循环、三重循环等。处于内部的循环叫做内循环，处于外部的循环叫做外循环。
   在设计多重循环时，要特别注意内、外循环之间的关系，以及各语句放置的位置。

   示例——若一个数等于它的各个真因子之和，则称该数为完数，如6=1+2+3，所以6是完数。求[1,500]之间的全部完数。

   for m = 1 : 500
       s = 0;
       for k = 1 : m / 2
           if rem(m , k) == 0
               s = s + k;
           end
       end
       if m == s
           disp(m);
       end
   end
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11

   >> exam10
        6
   
       28
   
      496
   
   1
   2
   3
   4
   5
   6
   7

   示例——用筛选法求某自然数范围内的全部素数。

   m = input('m = ');
   p = 1 : m;
   
   p(1) = 0;
   
   for i = 2 : sqrt(m)
       for j = 2 * i : i :m
           p(j) = 0;
       end
   end
   
   n = find(p ~= 0);
   p(n)
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13

   >> exam11
   m = 10
   
   ans =
   
        2     3     5     7
   1
   2
   3
   4
   5
   6