switch 与 if-elseif-else 伪代码教程

一、概念与适用场景

• if-elseif-else：多条件分支结构，通过逐个判断条件真假执行对应分支，适合条件表达式复杂（如范围判断、逻辑组合）的场景。
• switch：多值匹配结构，通过一个表达式的值与多个常量匹配执行对应分支，适合单一变量的离散值判断（如枚举、状态码）。

二、if-elseif-else 伪代码

1. 基本结构

if 条件1 then
    操作1  // 条件1为真时执行
elseif 条件2 then
    操作2  // 条件1为假、条件2为真时执行
elseif 条件3 then
    操作3  // 前两个条件为假、条件3为真时执行
...
else
    默认操作  // 所有条件都为假时执行（可选）
end if

2. 示例：根据分数评级

// 输入分数（0-100），输出评级
input score
if score >= 90 then
    output "优秀"
elseif score >= 80 then
    output "良好"
elseif score >= 60 then
    output "及格"
else
    output "不及格"
end if

逻辑说明：条件按顺序判断，一旦某条件为真则执行对应操作并退出结构（后续条件不再判断）。

三、switch 伪代码

1. 基本结构

switch (表达式)
case 常量1:
    操作1  // 表达式值等于常量1时执行
    break  // 退出switch结构（可选，根据逻辑决定）
case 常量2:
    操作2  // 表达式值等于常量2时执行
    break
...
default:
    默认操作  // 表达式值不匹配任何常量时执行（可选）
    break
end switch

2. 示例：根据星期数输出对应名称

// 输入星期数（1-7），输出星期名称
input weekday
switch (weekday)
case 1:
    output "星期一"
    break
case 2:
    output "星期二"
    break
case 3:
    output "星期三"
    break
case 4:
    output "星期四"
    break
case 5:
    output "星期五"
    break
case 6:
    output "星期六"
    break
case 7:
    output "星期日"
    break
default:
    output "输入无效"
    break
end switch

逻辑说明：

• case 后必须是常量（如数字、字符），不能是范围或变量。
• break 用于避免“穿透”（即执行完当前 case 后继续执行下一个 case），若需多值执行同一操作可省略 break（见扩展示例）。

四、扩展示例：多值共享操作

// 输入月份（1-12），判断季节（3-5春，6-8夏，9-11秋，12-2冬）
input month
switch (month)
case 3:
case 4:
case 5:
    output "春季"
    break
case 6:
case 7:
case 8:
    output "夏季"
    break
case 9:
case 10:
case 11:
    output "秋季"
    break
case 12:
case 1:
case 2:
    output "冬季"
    break
default:
    output "月份无效"
    break
end switch

五、两种结构的对比

特性	if-elseif-else	switch
判断依据	条件表达式（可含范围、逻辑运算）	单一表达式与常量的精确匹配
执行顺序	按条件顺序判断，可能部分判断	直接匹配对应 case，效率更高
灵活性	高（支持任意条件）	低（仅支持离散常量匹配）
适用场景	范围判断、复杂逻辑	状态码、枚举值等离散值判断

六、练习题

1. 用 if-elseif-else 实现：输入一个整数，判断其是否为正数、负数或零。
2. 用 switch 实现：输入一个字符（'A'/'B'/'C'/'D'），输出对应等级（优秀/良好/及格/不及格）。

通过练习可掌握两种分支结构的逻辑设计，根据实际场景选择更合适的表达方式。

以下是关于do-while循环、嵌套循环和递归函数的伪代码详细教程，包含概念解析、结构示例、应用场景及练习题，帮助你系统掌握这三种核心算法结构。

一、do-while循环：后测试循环的典型代表

1. 概念与核心特性

do-while循环是先执行循环体，再判断条件的循环结构。无论条件是否成立，循环体至少会执行一次，适合需要“先做后判断”的场景（如用户输入验证）。

2. 伪代码基本结构

do
    循环体操作  // 至少执行一次
while (循环条件);  // 条件为真则重复执行，为假则退出
end do  // 可选，用于标记循环结束

3. 经典示例

示例1：累加1到n的和（确保至少加1）

input n  // 输入一个正整数
sum ← 0
i ← 1
do
    sum ← sum + i  // 累加当前i的值
    i ← i + 1      // 计数器递增
while (i ≤ n)  // 当i超过n时停止
output "1到", n, "的和为：", sum

• 执行逻辑：即使n=0（输入非法），循环体仍会执行1次（sum=1），避免“未执行”的空结果。

示例2：用户输入验证（确保输入有效）

// 要求用户输入1-100之间的整数，直到输入合法为止
do
    output "请输入1-100之间的整数："
    input num
while (num < 1 or num > 100)  // 输入不合法则重复提示
output "您输入的合法数字是：", num

二、嵌套循环：多层循环的组合应用

1. 概念与核心特性

嵌套循环指一个循环的内部包含另一个完整循环，外层循环控制“轮次”，内层循环控制每轮的“重复操作”。常见于二维数据处理（如矩阵、表格）。

2. 伪代码基本结构

// 外层循环（以while为例）
外层变量 ← 初始值
while (外层条件) do
    外层循环操作
    // 内层循环（以for为例）
    for 内层变量 ← 初始值 to 终止值 do
        内层循环操作  // 外层循环每执行1次，内层循环完整执行一轮
    end for
    外层变量更新
end while

3. 经典示例

示例1：打印5行5列的数字矩阵（每行数字递增）

row ← 1  // 控制行数
while (row ≤ 5) do
    col ← 1  // 控制每行的列数
    while (col ≤ 5) do
        output row * 10 + col, " "  // 生成如11,12,...55的数字
        col ← col + 1
    end while
    output 换行  // 每行结束后换行
    row ← row + 1
end while

• 输出结果：
  11 12 13 14 15
  21 22 23 24 25
  ...
  51 52 53 54 55

示例2：计算1到100中所有质数（素数）

// 质数：大于1的自然数，除了1和自身外无其他因数
for num ← 2 to 100 do  // 外层循环：遍历2到100的数
    is_prime ← true  // 标记是否为质数
    for i ← 2 to num-1 do  // 内层循环：检查是否有除1和自身外的因数
        if num mod i == 0 then  // 若能被i整除，不是质数
            is_prime ← false
            break  // 提前退出内层循环
        end if
    end for
    if is_prime then
        output num, "是质数"
    end if
end for

三、递归函数：自我调用的问题分解工具

1. 概念与核心特性

递归函数是在函数体内调用自身的函数，通过将复杂问题分解为“与原问题相似但规模更小的子问题”解决。核心要素：

• 终止条件：避免无限递归（如n=0时返回确定值）；
• 递归关系：原问题与子问题的关联（如n! = n × (n-1)!）。

2. 伪代码基本结构

function 函数名(参数) 返回类型
    if (终止条件) then  // 最小子问题的解
        return 基础值
    else  // 分解为子问题
        return 子问题处理 + 当前步骤操作
    end if
end function

3. 经典示例

示例1：计算n的阶乘（n! = n × (n-1) × ... × 1）

function factorial(n integer) integer
    if (n == 0) then  // 终止条件：0! = 1
        return 1
    else  // 递归关系：n! = n × (n-1)!
        return n * factorial(n - 1)
    end if
end function

// 调用示例：计算5!
output factorial(5)  // 结果为120

• 递归过程：
  factorial(5) = 5 × factorial(4)
factorial(4) = 4 × factorial(3)
  ...
  factorial(1) = 1 × factorial(0) = 1 × 1 = 1

示例2：汉诺塔问题（将n个盘子从A柱移到C柱，B柱为辅助，大盘不能压小盘）

// 参数：n（盘子数量），A（源柱），B（辅助柱），C（目标柱）
procedure hanoi(n integer, A char, B char, C char)
    if (n == 1) then  // 终止条件：1个盘子直接移到目标柱
        output "将盘子从", A, "移到", C
    else
        // 步骤1：将n-1个盘子从A移到B（C为辅助）
        hanoi(n-1, A, C, B)
        // 步骤2：将第n个盘子从A移到C
        output "将盘子从", A, "移到", C
        // 步骤3：将n-1个盘子从B移到C（A为辅助）
        hanoi(n-1, B, A, C)
    end if
end procedure

// 调用示例：移动3个盘子
hanoi(3, 'A', 'B', 'C')

• 输出结果：
  将盘子从A移到C
  将盘子从A移到B
  将盘子从C移到B
  将盘子从A移到C
  将盘子从B移到A
  将盘子从B移到C
  将盘子从A移到C

四、练习题：巩固伪代码编写能力

1. 用do-while循环实现：计算用户输入的若干个整数的平均值（输入0时停止）。
2. 用嵌套循环实现：打印一个10行的直角三角形（第i行有i个星号）。
3. 用递归函数实现：计算两个数的最大公约数（基于“gcd(a,b) = gcd(b,a mod b)”，终止条件b=0时返回a）。

五、总结

• do-while循环：适合“先执行后判断”的场景，确保循环体至少运行一次；
• 嵌套循环：通过多层循环处理多维数据，外层控轮次、内层控细节；
• 递归函数：通过自我调用分解问题，核心是明确终止条件和递归关系。

掌握这三种结构，能有效提升算法设计的灵活性，为复杂问题的解决提供基础工具。

流程图描述

以下是用类似 C++ 风格的伪代码来描述一些简单算法的例子，它们体现了 C++ 编程中常见的操作，如变量声明、条件判断、循环等。

1. 计算两个数的乘积

// 定义主函数
function main()
    // 声明两个整数变量用于存储输入的数字
    int num1, num2;
    // 声明一个整数变量用于存储乘积结果
    int product;

    // 提示用户输入第一个数字
    output "请输入第一个数字: ";
    // 从用户那里获取第一个数字
    input num1;

    // 提示用户输入第二个数字
    output "请输入第二个数字: ";
    // 从用户那里获取第二个数字
    input num2;

    // 计算两个数字的乘积
    product = num1 * num2;

    // 输出计算得到的乘积
    output "这两个数字的乘积是: ", product;
end function

2. 判断一个数是否为正数

// 定义主函数
function main()
    // 声明一个整数变量用于存储输入的数字
    int number;

    // 提示用户输入一个数字
    output "请输入一个数字: ";
    // 从用户那里获取数字
    input number;

    // 判断数字是否为正数
    if number > 0 then
        output number, " 是正数。";
    else
        output number, " 不是正数。";
    end if
end function

3. 计算 1 到 n 的累加和

// 定义主函数
function main()
    // 声明一个整数变量用于存储输入的上限值
    int n;
    // 声明一个整数变量用于存储累加和，初始值设为 0
    int sum = 0;
    // 声明一个整数变量作为循环计数器，初始值设为 1
    int i = 1;

    // 提示用户输入一个正整数
    output "请输入一个正整数: ";
    // 从用户那里获取正整数
    input n;

    // 使用 while 循环进行累加操作
    while i <= n do
        sum = sum + i;
        i = i + 1;
    end while

    // 输出累加和
    output "1 到 ", n, " 的累加和是: ", sum;
end function

4. 找出数组中的最小值

// 定义主函数
function main()
    // 声明一个整数数组用于存储输入的数据
    int arr[100];
    // 声明一个整数变量用于存储数组的长度
    int length;
    // 声明一个整数变量用于存储最小值，初始设为一个较大的值
    int min = 9999;
    // 声明一个整数变量作为循环计数器
    int i;

    // 提示用户输入数组的长度
    output "请输入数组的长度: ";
    // 从用户那里获取数组长度
    input length;

    // 提示用户输入数组元素
    output "请输入数组的元素: ";
    for i = 0 to length - 1 do
        input arr[i];
    end for

    // 遍历数组找出最小值
    for i = 0 to length - 1 do
        if arr[i] < min then
            min = arr[i];
        end if
    end for

    // 输出数组中的最小值
    output "数组中的最小值是: ", min;
end function

5. 交换两个变量的值

// 定义主函数
function main()
    // 声明两个整数变量用于存储要交换的值
    int a, b;
    // 声明一个整数变量作为临时存储
    int temp;

    // 提示用户输入第一个变量的值
    output "请输入第一个变量的值: ";
    // 从用户那里获取第一个变量的值
    input a;

    // 提示用户输入第二个变量的值
    output "请输入第二个变量的值: ";
    // 从用户那里获取第二个变量的值
    input b;

    // 交换两个变量的值
    temp = a;
    a = b;
    b = temp;

    // 输出交换后的变量值
    output "交换后第一个变量的值是: ", a;
    output "交换后第二个变量的值是: ", b;
end function

这些伪代码示例使用了 C++ 编程中常见的语法元素，如变量声明、输入输出、条件判断和循环等，你可以根据这些伪代码快速转化为实际的 C++ 代码。

一、算法的概念

算法是解决特定问题的有限、明确、有序的操作步骤集合，具有以下特性：

1. 有穷性：步骤有限，不会无限循环；
2. 确定性：每一步操作无歧义；
3. 可行性：可通过基本运算实现；
4. 输入输出：有0个或多个输入，至少1个输出。

二、伪代码描述的特点

伪代码是一种介于自然语言和编程语言之间的算法描述方式，用简洁的符号和结构表示逻辑，无需严格遵循语法规则，但需清晰体现程序流程。

• 优势：
  • 比自然语言更严谨，接近编程逻辑；
  • 比代码更易读，适合快速设计算法。
• 核心元素：
  • 变量、赋值、输入输出；
  • 条件判断（if/else）、循环（for/while）；
  • 函数、数组等数据结构。

三、伪代码常用符号与结构

1. 变量与赋值

• 定义：变量名 类型（如 n integer）；
• 赋值：变量名 ← 表达式（或 =）。
  示例：

sum ← 0  // 初始化变量sum为0
i ← 1    // 初始化变量i为1

2. 输入与输出

• 输入：input 变量名（或 read 变量名）；
• 输出：output 表达式（或 print 表达式）。
  示例：

input x  // 输入x的值
output "结果为：", x  // 输出结果

3. 条件判断（if语句）

• 单分支：

  if 条件 then
      操作1
  end if
  

• 双分支：

  if 条件 then
      操作1
  else
      操作2
  end if
  

示例：判断奇偶性

if n % 2 == 0 then
    output "偶数"
else
    output "奇数"
end if

4. 循环结构

• for循环（计数循环）：

  for 变量 ← 初始值 to 终止值 step 步长 do
      循环体
  end for
  

  （注：step可省略，默认步长为1）
• while循环（条件循环）：

  while 条件 do
      循环体
  end while
  

示例：计算1+2+…+100

sum ← 0
i ← 1
while i ≤ 100 do
    sum ← sum + i
    i ← i + 1
end while
output sum

5. 函数与数组

• 函数定义：

  function 函数名(参数列表) 返回类型
      函数体
      return 返回值
  end function
  

• 数组操作：
  • 访问元素：数组名[索引]（索引从0或1开始，需注明）；
  • 数组长度：length(数组名)。
    示例：求数组最大值

function max(arr array) integer
    max_val ← arr[0]
    for i ← 1 to length(arr)-1 do
        if arr[i] > max_val then
            max_val ← arr[i]
        end if
    end for
    return max_val
end function

四、伪代码描述算法示例

以下通过经典算法演示伪代码的写法。

示例1：冒泡排序（升序）

算法思路：重复遍历数组，交换相邻逆序元素，使较大元素“冒泡”到右侧。

procedure bubbleSort(arr array)
    n ← length(arr)
    for i ← 0 to n-2 do        // 外层循环：n-1轮排序
        swapped ← false       // 标记是否发生交换
        for j ← 0 to n-2-i do  // 内层循环：每轮确定第i大的元素
            if arr[j] > arr[j+1] then
                swap arr[j] and arr[j+1]  // 交换元素
                swapped ← true
            end if
        end for
        if not swapped then  // 若某轮未交换，说明已有序，提前终止
            break
        end if
    end for
end procedure

示例2：二分查找（有序数组中查找目标值）

算法思路：通过不断将数组折半，缩小查找范围。

function binarySearch(arr sorted array, target integer) integer
    left ← 0
    right ← length(arr) - 1
    while left ≤ right do
        mid ← (left + right) // 2  // 计算中间索引
        if arr[mid] == target then
            return mid  // 查找成功，返回索引
        else if arr[mid] < target then
            left ← mid + 1  // 目标在右半区
        else
            right ← mid - 1  // 目标在左半区
        end if
    end while
    return -1  // 查找失败，返回-1
end function

示例3：欧几里得算法（求最大公约数）

算法思路：利用辗转相除法，用较大数除以较小数，取余数重复此过程。

function gcd(a integer, b integer) integer
    while b ≠ 0 do
        temp ← b
        b ← a mod b
        a ← temp
    end while
    return a
end function

五、伪代码编写规范与技巧

1. 结构清晰：
   • 用缩进区分代码块（如if、for、while的嵌套）；
   • 关键步骤添加注释（如// 初始化变量）。
2. 避免歧义：
   • 明确数组索引起始值（如“假设数组索引从0开始”）；
   • 运算符需清晰（如mod表示取余，//表示整除）。
3. 简化细节：
   • 无需处理数据类型转换、异常捕获等编程细节；
   • 复杂操作可封装为函数（如swap、max）。

六、伪代码与编程语言的转换

伪代码是代码实现的“蓝图”，可直接映射到具体编程语言（如C++、Python）。
示例：伪代码转C++

// 伪代码
function sum(n integer) integer
    s ← 0
    for i ← 1 to n do
        s ← s + i
    end for
    return s
end function

// C++代码
int sum(int n) {
    int s = 0;
    for (int i = 1; i <= n; i++) {
        s += i;
    }
    return s;
}

七、练习：用伪代码描述算法

尝试用伪代码描述以下问题的算法：

1. 求斐波那契数列第n项（第一项为1，第二项为1，后续每项为前两项之和）。
2. 判断一个数是否为完全平方数（如25=5²，是完全平方数）。
3. 选择排序（每轮找到最小元素，与当前位置交换）。

提示：

• 先确定输入输出和变量定义；
• 用循环和条件判断实现逻辑；
• 关键步骤添加注释说明。

八、总结

伪代码是连接算法思路与编程实现的桥梁，其核心在于：

• 逻辑优先：聚焦算法步骤，而非语法细节；
• 简洁直观：用清晰的结构和符号表达流程；
• 易于转换：为后续代码编写提供明确指引。

通过练习伪代码描述，可有效提升算法设计能力，为编程实现打下坚实基础。