Rust专项——九九乘法表：四种方向的实现详解

红目香薰

发布于 2025-12-16 16:06:48

2200

文章被收录于专栏：CSDNToQQCodeCSDNToQQCode

引言

九九乘法表是编程初学者的经典练习，也是掌握嵌套循环的绝佳案例。在Rust中，我们可以用不同的方式打印九九乘法表，每种方式都展现了不同的编程技巧和Rust特性。

本文将详细讲解如何在Rust中实现九九乘法表的四种方向：

标准方向：左上到右下，完整的乘法表
上三角方向：只显示上三角部分（i≤j）
下三角方向：只显示下三角部分（i≥j）
倒序方向：从大到小的反向打印

每种实现方式都将包含：

核心代码实现
代码详细解析
输出效果展示
优化版本和变体
Rust特性应用

通过本文的学习，你将能够：

熟练使用嵌套循环解决实际问题
理解不同循环控制的方式
掌握Rust的格式化输出
学习代码优化和重构技巧

1. 标准九九乘法表（完整版）

1.1 基本实现

这是最常见的九九乘法表格式，显示所有9×9的乘法结果：

fn main() {
    println!("=== 标准九九乘法表 ===");
    
    for i in 1..=9 {
        for j in 1..=9 {
            print!("{}×{}={}\t", j, i, i * j);
        }
        println!();
    }
}

输出效果：

代码解析：

i 控制行（被乘数）
j 控制列（乘数）
使用 \t（制表符）对齐
每行结束后用 println!() 换行

1.2 优化版本：对齐格式

fn main() {
    println!("=== 标准九九乘法表（对齐版） ===");
    
    for i in 1..=9 {
        for j in 1..=9 {
            print!("{:2}×{:2}={:2}\t", j, i, i * j);
        }
        println!();
    }
}

代码解析：

{:2} 表示最小宽度为2，右对齐
确保数字小于10时也有固定宽度

1.3 添加分隔线和标题

fn main() {
    println!("=== 标准九九乘法表（完整版） ===");
    // 使用 format! 进行字符串拼接，避免直接使用 + 运算符
    println!("┌{}┐", "─".repeat(80));
    
    for i in 1..=9 {
        print!("│ ");
        for j in 1..=9 {
            // 使用 {:<8} 控制宽度（原 \t 可能导致对齐不一致）
            print!("{}×{}={:<8}", j, i, i * j);
        }
        println!("│");
        if i < 9 {
            println!("├{}┤", "─".repeat(80));
        }
    }
    
    println!("└{}┘", "─".repeat(80));
}

关键点：

使用 {:<3} 左对齐，宽度3
使用Unicode字符绘制表格边框

2. 上三角九九乘法表（i ≤ j）

2.1 基本实现

只显示上三角部分，避免重复显示相同的乘法（如3×2和2×3）：

fn main() {
    println!("=== 上三角九九乘法表 ===");
    
    for i in 1..=9 {
        for j in 1..=9 {
            if j >= i {  // 只显示 j >= i 的部分
                print!("{}×{}={}\t", i, j, i * j);
            } else {
                print!("\t");  // 空白对齐·看情况写一个或两个\t
            }
        }
        println!();
    }
}

输出效果：

2.2 优化版本：紧凑对齐

fn main() {
    println!("=== 上三角九九乘法表（紧凑版） ===");
    
    for i in 1..=9 {
        for _ in 1..i {
            print!("        ");  // 8个空格对齐
        }
        for j in i..=9 {
            print!("{}×{}={:<3}\t", i, j, i * j);
        }
        println!();
    }
}

代码解析：

第一个循环打印前导空格
第二个循环只打印 j>=i 的部分
更清晰的控制流

2.3 使用continue优化

fn main() {
    println!("=== 上三角九九乘法表（continue版） ===");
    
    for i in 1..=9 {
        for j in 1..=9 {
            if j < i {
                print!("        ");  // 空白
                continue;
            }
            print!("{}×{}={:<3}\t", i, j, i * j);
        }
        println!();
    }
}

3. 下三角九九乘法表（i ≥ j）

3.1 基本实现

只显示下三角部分，另一种避免重复的方式：

fn main() {
    println!("=== 下三角九九乘法表 ===");
    
    for i in 1..=9 {
        for j in 1..=i {  // 只显示 j <= i 的部分
            print!("{}×{}={}\t", j, i, i * j);
        }
        println!();
    }
}

输出效果：

代码解析：

j 的范围是 1..=i，而不是 1..=9
每行的项数等于行号
更简洁的实现

3.2 优化版本：更好的对齐

fn main() {
    println!("=== 下三角九九乘法表（对齐版） ===");
    
    for i in 1..=9 {
        for j in 1..=i {
            print!("{}×{}={:<3}\t", j, i, i * j);
        }
        // 填充剩余空格以对齐
        for _ in (i + 1)..=9 {
            print!("        ");
        }
        println!();
    }
}

3.3 使用不同的格式

fn main() {
    println!("=== 下三角九九乘法表（格式化版） ===");
    
    for i in 1..=9 {
        for j in 1..=i {
            let result = i * j;
            if result < 10 {
                print!("{}×{}={}    ", j, i, result);
            } else {
                print!("{}×{}={}   ", j, i, result);
            }
        }
        println!();
    }
}

4. 倒序九九乘法表（从大到小）

4.1 基本实现

从9×9开始，倒序打印到1×1：

fn main() {
    println!("=== 倒序九九乘法表 ===");
    
    for i in (1..=9).rev() {  // 从9到1
        for j in (1..=9).rev() {  // 从9到1
            print!("{}×{}={}\t", j, i, i * j);
        }
        println!();
    }
}

输出效果：

**代码解析**：
- `(1..=9).rev()` 使用迭代器的 `rev()` 方法反转
- 从大到小的打印顺序

### 4.2 倒序下三角版本

```rust
fn main() {
    println!("=== 倒序下三角九九乘法表 ===");
    
    for i in (1..=9).rev() {
        for j in (1..=i).rev() {  // 倒序的下三角
            print!("{}×{}={}\t", j, i, i * j);
        }
        println!();
    }
}

输出效果：

4.3 倒序上三角版本

fn main() {
    println!("=== 倒序上三角九九乘法表 ===");
    
    for i in (1..=9).rev() {
        for j in (1..=9).rev() {
            if j >= i {
                print!("{}×{}={}\t", i, j, i * j);
            } else {
                print!("\t\t");
            }
        }
        println!();
    }
}

5. 综合对比与代码重构

5.1 统一接口的函数式实现

enum TableType {
    Full,        // 完整版
    UpperTri,    // 上三角
    LowerTri,    // 下三角
    Reverse,     // 倒序
}

fn print_multiplication_table(table_type: TableType) {
    match table_type {
        TableType::Full => {
            println!("=== 标准九九乘法表 ===");
            for i in 1..=9 {
                for j in 1..=9 {
                    print!("{}×{}={:<3}\t", j, i, i * j);
                }
                println!();
            }
        }
        
        TableType::UpperTri => {
            println!("=== 上三角九九乘法表 ===");
            for i in 1..=9 {
                for _ in 1..i {
                    print!("        ");
                }
                for j in i..=9 {
                    print!("{}×{}={:<3}\t", i, j, i * j);
                }
                println!();
            }
        }
        
        TableType::LowerTri => {
            println!("=== 下三角九九乘法表 ===");
            for i in 1..=9 {
                for j in 1..=i {
                    print!("{}×{}={:<3}\t", j, i, i * j);
                }
                println!();
            }
        }
        
        TableType::Reverse => {
            println!("=== 倒序九九乘法表 ===");
            for i in (1..=9).rev() {
                for j in (1..=9).rev() {
                    print!("{}×{}={:<3}\t", j, i, i * j);
                }
                println!();
            }
        }
    }
}

fn main() {
    print_multiplication_table(TableType::Full);
    println!();
    print_multiplication_table(TableType::UpperTri);
    println!();
    print_multiplication_table(TableType::LowerTri);
    println!();
    print_multiplication_table(TableType::Reverse);
}

5.2 使用结构体和方法

struct MultiplicationTable {
    size: u32,
}

impl MultiplicationTable {
    fn new(size: u32) -> Self {
        Self { size }
    }
    
    fn print_full(&self) {
        println!("=== 标准九九乘法表（{}×{}） ===", self.size, self.size);
        for i in 1..=self.size {
            for j in 1..=self.size {
                print!("{}×{}={:<3}\t", j, i, i * j);
            }
            println!();
        }
    }
    
    fn print_upper_triangle(&self) {
        println!("=== 上三角九九乘法表（{}×{}） ===", self.size, self.size);
        for i in 1..=self.size {
            for _ in 1..i {
                print!("        ");
            }
            for j in i..=self.size {
                print!("{}×{}={:<3}\t", i, j, i * j);
            }
            println!();
        }
    }
    
    fn print_lower_triangle(&self) {
        println!("=== 下三角九九乘法表（{}×{}） ===", self.size, self.size);
        for i in 1..=self.size {
            for j in 1..=i {
                print!("{}×{}={:<3}\t", j, i, i * j);
            }
            println!();
        }
    }
    
    fn print_reverse(&self) {
        println!("=== 倒序九九乘法表（{}×{}） ===", self.size, self.size);
        for i in (1..=self.size).rev() {
            for j in (1..=self.size).rev() {
                print!("{}×{}={:<3}\t", j, i, i * j);
            }
            println!();
        }
    }
}

fn main() {
    let table = MultiplicationTable::new(9);
    
    table.print_full();
    println!();
    table.print_upper_triangle();
    println!();
    table.print_lower_triangle();
    println!();
    table.print_reverse();
}

6. 高级特性应用

6.1 使用迭代器和函数式风格

fn main() {
    println!("=== 使用迭代器的九九乘法表 ===");
    
    (1..=9)
        .map(|i| {
            (1..=9)
                .map(|j| format!("{}×{}={}", j, i, i * j))
                .collect::<Vec<_>>()
                .join("\t")
        })
        .for_each(|row| println!("{}", row));
}

6.2 上三角的迭代器版本

fn main() {
    println!("=== 迭代器版上三角九九乘法表 ===");
    
    for i in 1..=9 {
        let padding: String = (1..i).map(|_| "        ").collect();
        let row: String = (i..=9)
            .map(|j| format!("{}×{}={:<3}", i, j, i * j))
            .collect::<Vec<_>>()
            .join("\t");
        println!("{}{}", padding, row);
    }
}

6.3 使用宏简化代码

macro_rules! print_cell {
    ($a:expr, $b:expr) => {
        print!("{}×{}={:<3}\t", $a, $b, $a * $b);
    };
}

fn main() {
    println!("=== 使用宏的九九乘法表 ===");
    
    for i in 1..=9 {
        for j in 1..=9 {
            print_cell!(j, i);
        }
        println!();
    }
}

7. 性能优化和最佳实践

7.1 字符串预分配

fn main() {
    println!("=== 优化版九九乘法表 ===");
    
    // 预分配字符串，减少内存分配
    let mut output = String::with_capacity(1000);
    
    for i in 1..=9 {
        output.clear();
        for j in 1..=9 {
            output.push_str(&format!("{}×{}={:<3}\t", j, i, i * j));
        }
        println!("{}", output);
    }
}

7.2 避免重复计算

fn main() {
    println!("=== 避免重复计算的九九乘法表 ===");
    
    for i in 1..=9 {
        for j in 1..=i {  // 只计算下三角
            let result = i * j;
            print!("{}×{}={:<3}\t", j, i, result);
        }
        println!();
    }
}

8. 美化输出版本

8.1 带边框的表格

fn main() {
    println!("╔══════════════════════════════════════════════════════════════╗");
    println!("║                   九九乘法表                                ║");
    println!("╠══════════════════════════════════════════════════════════════╣");
    
    for i in 1..=9 {
        print!("║ ");
        for j in 1..=9 {
            print!("{}×{}={:<3}\t", j, i, i * j);
        }
        println!("║");
    }
    
    println!("╚══════════════════════════════════════════════════════════════╝");
}

8.2 彩色输出（使用ANSI转义码）

fn main() {
    const RESET: &str = "\x1b[0m";
    const RED: &str = "\x1b[31m";
    const GREEN: &str = "\x1b[32m";
    const YELLOW: &str = "\x1b[33m";
    
    println!("=== 彩色九九乘法表 ===");
    
    for i in 1..=9 {
        for j in 1..=9 {
            let color = if i == j {
                RED
            } else if i * j < 10 {
                GREEN
            } else {
                YELLOW
            };
            
            print!("{}{}×{}={:<3}{}\t", color, j, i, i * j, RESET);
        }
        println!();
    }
}

9. 完整示例程序

use std::io;

fn show_menu() {
    println!("\n=== 九九乘法表程序 ===");
    println!("1. 标准九九乘法表（完整版）");
    println!("2. 上三角九九乘法表");
    println!("3. 下三角九九乘法表");
    println!("4. 倒序九九乘法表");
    println!("5. 显示所有版本");
    println!("0. 退出");
    print!("请选择（0-5）: ");
}

fn print_full_table() {
    println!("\n=== 标准九九乘法表 ===");
    for i in 1..=9 {
        for j in 1..=9 {
            print!("{}×{}={:<3}\t", j, i, i * j);
        }
        println!();
    }
}

fn print_upper_triangle() {
    println!("\n=== 上三角九九乘法表 ===");
    for i in 1..=9 {
        for _ in 1..i {
            print!("        ");
        }
        for j in i..=9 {
            print!("{}×{}={:<3}\t", i, j, i * j);
        }
        println!();
    }
}

fn print_lower_triangle() {
    println!("\n=== 下三角九九乘法表 ===");
    for i in 1..=9 {
        for j in 1..=i {
            print!("{}×{}={:<3}\t", j, i, i * j);
        }
        println!();
    }
}

fn print_reverse() {
    println!("\n=== 倒序九九乘法表 ===");
    for i in (1..=9).rev() {
        for j in (1..=9).rev() {
            print!("{}×{}={:<3}\t", j, i, i * j);
        }
        println!();
    }
}

fn print_all() {
    print_full_table();
    println!();
    print_upper_triangle();
    println!();
    print_lower_triangle();
    println!();
    print_reverse();
}

fn main() {
    loop {
        show_menu();
        
        let mut choice = String::new();
        io::stdin()
            .read_line(&mut choice)
            .expect("读取输入失败");
        
        let choice: u32 = match choice.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("无效输入，请重新选择！");
                continue;
            }
        };
        
        match choice {
            1 => print_full_table(),
            2 => print_upper_triangle(),
            3 => print_lower_triangle(),
            4 => print_reverse(),
            5 => print_all(),
            0 => {
                println!("再见！");
                break;
            }
            _ => println!("无效选择，请重新输入！"),
        }
    }
}

10. 总结对比

10.1 四种方向的对比表

方向	特点	循环范围	适用场景
标准版	显示所有乘积	1..=9 × 1..=9	完整学习乘法
上三角	避免重复，j≥i	j in i..=9	简洁展示，节省空间
下三角	避免重复，j≤i	j in 1..=i	最简洁的实现
倒序版	从大到小	(1..=9).rev()	反向思维训练