智能程序设计（C语言）

函数 (III) · 递归

计算机学院    杨已彪

yangyibiao@nju.edu.cn

提纲

• 递归是什么 (两个要素、信任递归)

• 递归执行过程 (层层递推与回归)

• 经典案例: Fibonacci (弹性)、汉诺塔

• 常见错误与课堂编码 (基础 3 题 + 案例 5 题)

• 分治与快速排序 (弹性)

• 课堂小测

递归是什么

递归: 函数直接或间接地自己调用自己——有些问题的定义本身就是递归的: 阶乘、汉诺塔、目录遍历……

/* 阶乘: n! = n × (n-1)! */
long long f(long long n)
{
  if (n == 0) {            /* 基准: 0! = 1, 唯一的奠基 */
    return 1;
  }
  return n * f(n - 1);     /* 递归: 1! 由 0! 归纳出来 */
}

/* 求幂: x^n = x × x^(n-1), 可以精简成一行 */
int power(int x, int n) {
    return n == 0 ? 1 : x * power(x, n - 1);
}

递归执行过程: 压栈与返回

Fibonacci 数列

#include <stdio.h>
long long fib(long long n)
{
  if (n == 0) {              /* 奠基之一: F(0) = 0 */
    return 0;
  }
  if (n == 1) {              /* 奠基之二: F(1) = 1 */
    return 1;
  }
  return fib(n - 1) + fib(n - 2);
}
int main(void)
{
  printf("fib(10) = %lld\n", fib(10));
  return 0;
}

Hanoi 塔 · 任务与规则

Hanoi 塔 · 盘子动画

Hanoi 塔

/* hanoi.c: A = 起始柱, B = 辅助柱, C = 目标柱;
   n = 本次要移的盘数 (最大盘编号) */
#include <stdio.h>

void Hanoi(int n, char A, char B, char C)
{
  if (n == 1) {
    /* 基准: 只剩一个盘 */
    printf("盘 %d: %c -> %c\n", n, A, C);
  } else {
    /* 上面 n-1 个: A -> B (借 C) */
    Hanoi(n - 1, A, C, B);
    /* 最大盘: A -> C */
    printf("盘 %d: %c -> %c\n", n, A, C);
    /* 上面 n-1 个: B -> C (借 A) */
    Hanoi(n - 1, B, A, C);
  }
}

int main(void)
{
  /* 3 个盘的完整移法 */
  Hanoi(3, 'A', 'B', 'C');
  return 0;
}

Hanoi 塔 · 调用过程与运行结果

动画里的 7 步, 正是下面这棵调用树逐层产生的:

Hanoi(3, A, B, C)
 ├─ Hanoi(2, A, C, B)        ← 先把上面 2 个 A→B
 │    ├─ Hanoi(1, A, B, C) → 盘1: A→C
 │    ├─ 盘2: A→B
 │    └─ Hanoi(1, C, A, B) → 盘1: C→B
 ├─ 盘3: A→C                 ← 最大盘就位
 └─ Hanoi(2, B, A, C)        ← 再把上面 2 个 B→C
      ├─ Hanoi(1, B, C, A) → 盘1: B→A
      ├─ 盘2: B→C
      └─ Hanoi(1, A, B, C) → 盘1: A→C

运行输出 (共 7 步): 盘1: A→C   盘2: A→B   盘1: C→B   盘3: A→C   盘1: B→A   盘2: B→C   盘1: A→C

常见错误

• 缺少基准情形: 递归永不终止 (如忘了 n==0 的判断)

• 问题没有缩小: 每次调用与上次规模相同 (如 f(n) 里调用 f(n))

写递归的两步检查: ① 基准情形对吗? ② 每次调用规模在变小吗?

→ 下一页: 现场演示"没有基准情形"的下场——调用栈爆掉

演示: 没有基准情形的栈溢出

/* 不规范: 少了基准情形 */
long long fact(int n)
{
  return n * fact(n - 1);
}

int main(void)
{
  printf("%lld\n", fact(5));
  return 0;
}

课堂编码: 基础三题

课堂编码 · 参考实现

int power(int x, int n)
{
  /* 基准 x^0=1; 递归 x × x^(n-1) */
  return n == 0 ? 1 : x * power(x, n - 1);
}

int sum(int n)
{
  /* 基准 0; 递归 n + sum(n-1) */
  return n == 0 ? 0 : n + sum(n - 1);
}

void print(int n)
{
  if (n / 10 == 0) {
    /* 基准: 一位数直接打印 */
    printf("%d", n);
  } else {
    /* 先递归打印前面几位 */
    print(n / 10);
    /* 回来再打印末位 —— 顺序是本题关键 */
    printf(" %d", n % 10);
  }
}

课堂案例: 递归求最大值与判断回文

课堂案例: 递归求最大值与判断回文 · 参考实现

int max_rec(int a[], int n)
{
  int rest;
  if (n == 1) {                    /* 基准情形 */
    return a[0];
  }
  rest = max_rec(a, n - 1);        /* 递归: 前 n-1 个的最大值 */
  return a[n - 1] > rest ? a[n - 1] : rest;
}

int is_pal(char s[], int l, int r)
{
  if (l >= r) {                    /* 基准: 0 或 1 个字符 */
    return 1;
  }
  return s[l] == s[r] && is_pal(s, l + 1, r - 1);
}

课堂案例: 二分查找

课堂案例: 二分查找 · 参考实现

int bin_search(int a[], int low, int high, int key)
{
  int mid;
  if (low > high) {                /* 基准: 没找到 */
    return -1;
  }
  mid = (low + high) / 2;
  if (a[mid] == key) {
    return mid;
  }
  if (a[mid] > key) {
    return bin_search(a, low, mid - 1, key);
  }
  return bin_search(a, mid + 1, high, key);
}

• 参数即状态: 递归函数的参数要能完整描述"当前子问题"——low、high 刻画查找区间, key 与 a 全程不变

• 每次调用区间必然缩小——这保证递归一定终止; 下一页分治法正是这个思想的放大版

课堂案例: 组合数与爬楼梯

课堂案例: 组合数与爬楼梯 · 参考实现

long comb(int m, int n)
{
  if (n == 0 || n == m) {          /* 基准情形 */
    return 1;
  }
  return comb(m - 1, n - 1) + comb(m - 1, n);
}

int climb(int n)
{
  if (n <= 1) {                    /* 基准情形 */
    return 1;
  }
  return climb(n - 1) + climb(n - 2);
}

分治法

分治法 (divide and conquer): 把大问题拆成几个同类的小问题, 分别解决, 再合并结果

• 三步: 分 (拆) → 治 (解决小问题) → 合 (拼起来)

• 生活例子: 整理一摞试卷——先按分数段分堆, 每堆再各自整理

• 排序中的分治 (快速排序): 选一个基准, 把数组划分成"小的在左、大的在右"两段, 再对两段各自递归——不需要合并 (划分完位置就对了); 过程见下一页

• ("分成两半各自排好再合并"是另一种排序——归并排序, 课下可以了解)

递归常常是分治法的自然结果——快速排序正是如此

分治图示: 快速排序

• ① 划分: 选基准 5, 小的放左、大的放右——5 的位置就此一次到位

• ② 治: 左段 [2, 1, 3] 和右段 [9, 8] 各自递归——同样先划分、再递归

• ③ 合: 什么都不用做——每次划分都把基准放到最终位置, 递归结束时整个数组就有序了

递归排序: 快速排序

用递归做排序: 选一个基准, 小的放左、大的放右, 再对左右递归

void quicksort(int a[], int low, int high)
{
  int middle;

  if (low >= high) {          /* 基准情形: 只剩 0 或 1 个元素 */
    return;
  }
  middle = split(a, low, high);       /* 划分: 小的在左, 大的在右 */
  quicksort(a, low, middle - 1);      /* 递归排左半 */
  quicksort(a, middle + 1, high);     /* 递归排右半 */
}

• 平均 O(n log n), 比之前三种排序的 O(n^2) 快得多

• split 是划分函数, 下一页展开

快速排序: 划分函数 split

int split(int a[], int low, int high)
{
  int part_element = a[low];

  for (;;) {
    while (low < high && part_element <= a[high]) {
      high--;
    }
    if (low >= high) {
      break;
    }
    a[low++] = a[high];

    while (low < high && a[low] <= part_element) {
      low++;
    }
    if (low >= high) {
      break;
    }
    a[high--] = a[low];
  }

  a[high] = part_element;
  return high;
}

课堂小测

1. 概念: 递归函数必须具备哪两个要素？
2. 概念: f(5) 计算 5! 的过程中，栈上最多同时压了几层调用？
3. 代码阅读: fib(5) 中 fib(2) 被计算了几次？这说明了什么？
4. 纠错: 递归函数忘了写基准情形会怎样？

未完待续