程序设计方法¶

概述¶

程序设计方法是指编写程序时所采用的方法和技巧。良好的程序设计方法可以提高程序的质量、可读性和可维护性。

结构化程序设计¶

结构化程序设计

结构化程序设计是一种程序设计方法,强调使用顺序、选择、循环三种基本结构。

基本结构¶

三种基本结构

1. 顺序结构¶

graph TB
    A[语句1] --> B[语句2]
    B --> C[语句3]

特点:

按顺序执行
每条语句执行一次

2. 选择结构¶

graph TB
    A{条件} -->|真| B[语句1]
    A -->|假| C[语句2]
    B --> D[后续]
    C --> D

特点:

根据条件选择执行路径
只执行一条路径

3. 循环结构¶

graph TB
    A[初始化] --> B{条件}
    B -->|真| C[循环体]
    C --> D[更新]
    D --> B
    B -->|假| E[后续]

特点:

重复执行循环体
直到条件不满足

结构化程序设计原则¶

设计原则

结构化程序设计遵循以下原则:

自顶向下: 从整体到局部逐步细化
逐步求精: 将复杂问题分解为简单问题
模块化: 将程序划分为独立模块
限制goto: 避免使用goto语句

优点¶

结构化程序设计优点

结构清晰
易于理解
易于验证
易于维护

模块化程序设计¶

模块的概念¶

模块

模块是具有独立功能的程序单元,具有明确的接口。

模块化设计原则¶

模块化设计原则

1. 信息隐藏¶

信息隐藏原则

模块内部实现细节对外不可见。

示例:

C
// 模块接口(stack.h)
void push(int value);
int pop(void);
int isEmpty(void);

// 模块实现(stack.c)
#include "stack.h"

static int stack[100];  // 隐藏的实现细节
static int top = 0;

void push(int value) {
    stack[top++] = value;
}

int pop(void) {
    return stack[--top];
}

int isEmpty(void) {
    return top == 0;
}

2. 高内聚¶

高内聚原则

模块内部元素紧密相关。

内聚类型:

功能内聚: 最高内聚,模块完成单一功能
顺序内聚: 模块内元素顺序执行
通信内聚: 模块内元素操作相同数据
过程内聚: 模块内元素按过程组织
时间内聚: 模块内元素同时执行
逻辑内聚: 模块内元素逻辑相关
偶然内聚: 最低内聚,元素无关联

3. 低耦合¶

低耦合原则

模块之间依赖关系尽可能少。

耦合类型:

内容耦合: 最高耦合,一个模块直接访问另一个模块内部
公共耦合: 模块访问公共数据
外部耦合: 模块访问外部数据
控制耦合: 一个模块控制另一个模块
标记耦合: 模块间传递数据结构
数据耦合: 模块间传递数据
无耦合: 最低耦合,模块完全独立

递归程序设计¶

递归的概念¶

递归

递归是函数直接或间接调用自身的过程。

递归的要素¶

递归的两个要素

基准情况: 递归终止条件
递归步骤: 问题规模缩小

递归示例¶

1. 阶乘¶

Python
def factorial(n):
    # 基准情况
    if n == 0 or n == 1:
        return 1
    # 递归步骤
    return n * factorial(n - 1)

2. 斐波那契数列¶

Python
def fibonacci(n):
    # 基准情况
    if n <= 1:
        return n
    # 递归步骤
    return fibonacci(n-1) + fibonacci(n-2)

3. 汉诺塔¶

Python
def hanoi(n, source, target, auxiliary):
    if n == 1:
        print(f"Move disk 1 from {source} to {target}")
        return
    
    hanoi(n-1, source, auxiliary, target)
    print(f"Move disk {n} from {source} to {target}")
    hanoi(n-1, auxiliary, target, source)

递归的优缺点¶

优点:

代码简洁
易于理解
适合分治问题

缺点:

空间开销大
可能栈溢出
效率可能较低

迭代程序设计¶

迭代的概念¶

迭代

迭代是使用循环结构重复执行代码的过程。

迭代示例¶

1. 阶乘(迭代)¶

Python
def factorial(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

2. 斐波那契数列(迭代)¶

Python
def fibonacci(n):
    if n <= 1:
        return n
    
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

递归与迭代的比较¶

特性	递归	迭代
空间复杂度	高(调用栈)	低
时间复杂度	可能较高	通常较低
代码可读性	好	可能较差
适用场景	分治、树遍历	简单重复

程序设计风格¶

良好的程序设计风格¶

程序设计风格

良好的程序设计风格提高程序的可读性和可维护性。

1. 命名规范¶

命名规范

使用有意义的名称
遵循命名约定
避免使用缩写

示例:

Python
# 好的命名
def calculate_average(numbers):
    total = sum(numbers)
    count = len(numbers)
    return total / count

# 不好的命名
def calc(nums):
    t = sum(nums)
    c = len(nums)
    return t / c

2. 注释规范¶

注释规范

解释为什么,而不是做什么
保持注释与代码同步
使用文档注释

示例:

Python
def binary_search(arr, target):
    """
    二分查找算法
    
    参数:
        arr: 已排序的数组
        target: 要查找的目标值
    
    返回:
        目标值的索引,如果不存在则返回-1
    """
    left, right = 0, len(arr) - 1
    
    while left <= right:
        mid = (left + right) // 2
        
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    
    return -1

3. 代码格式¶

使用一致的缩进
合理使用空行
控制每行长度

参考资料¶

程序设计方法百度百科