实例之递归

优点

递归使代码看起来更加整洁、优雅
可以用递归将复杂任务分解成更简单的子问题
使用递归比使用一些嵌套迭代更容易

缺点

递归逻辑很难调试，递归条件处理不好容易造成程序无法结束，直到达到最大递归错误
递归占用大量内存，耗费计算机资源

汉诺塔

#include <stdio.h>

//hanoi函数的意思就是把第一个字符型（x）移到第三个字符型（z）。
void hanoi(int n, char x, char y, char z);

void hanoi(int n, char x, char y, char z)
{
    if (n == 1)
    {
        printf("%c --> %c\n", x, z);
    }
    else
    {
        hanoi(n - 1, x, z, y); // 把x的放到y上，因为（n-1），所以剩下一个
        printf("%c -- > %c\n", x, z); // x剩下的一个放到z上
        hanoi(n - 1, y, x, z); // 把y的放到z上
        //不需要套用循环条件，只要是把自身调用结束了就相当于多次循环了
    }
}

int main()
{
    int n;

    printf("scanf_s one number:");

    scanf_s("%d", &n);

    hanoi(n, &#39;X&#39;, &#39;Y&#39;, &#39;Z&#39;);

    return 0;
}

快速排序

#include <stdio.h>

void quick_sort(int array[], int left, int right)
{
    int i = left, j = right;
    int temp;
    int pivot;

    pivot = array[(left + right) / 2];

    while (i <= j)
    {
        // 从左到右找到大于基准点的元素
        while (array[i] < pivot)
        {
            i++;
        }
        // 从左到有找到小于基准点的元素
        while (array[j] > pivot)
        {
            j--;
        }
        // 如果i <= j，则互换
        if (i <= j)
        {
            temp = array[i];
            array[i] = array[j];
            array[j] = temp;
            i++;
            j++;
        }
    }

    if (left < j)
    {
        quick_sort(array, left, j);
    }

    if (i < right)
    {
        quick_sort(array, i, right);
    }
}

int main()
{
    int array[] = {4, 1, 5, 7, 8, 3, 2, 9, 10, 6 };
    int i, length;

    length = sizeof(array) / sizeof(array[0]);
    quick_sort(array, 0, length - 1);

    return 0;
}

斐波那契数列
/法1/

#include <stdio.h>
#include <string.h>
#define N 20

int f[N + 1];

int fib(int n)

{
    if(f[n])
        return f[n];
    else if(n == 1 || n == 2)
        return f[n] = 1;
    else {
        if(f[n - 2] == 0) f[n - 2] = fib(n - 2);
        if(f[n - 1] == 0) f[n - 1] = fib(n - 1);
        return f[n] = f[n - 2] + f[n - 1];
    }
}

int main(void)
{
    memset(f, 0, sizeof(f));
    int n, a;
    scanf("%d", &n);
    while(n--) {
        scanf("%d", &a);
        printf("%d\n", fib(a));
    }
    return 0;
}

/法2/

#include <stdio.h>

int fib(int n)
{
    return(n == 1 || n == 2) ? 1 : fib(n-2) + fib(n-1);
}

int main()
{

    int n, a;
    scanf("%d", &n);
    while(n--){
    scanf("%d", &a);

    printf("%d\n", fib(a));
}
return 0;
}

模拟实现 树形结构的遍历

import os #引入文件操作模块
def findFile(file_Path):
    listRs = os.listdir(file_Path) # 得到该路径下所有的文件夹
    for eachitem in listRs:
        full_path = os.path.join(file_Path, eachitem) # 获取完整的文件路径
        if os.path.isdir(full_path): # 判断是否是文件夹
            findFile(full_path) # 如果是一个文件夹 再次去递归
            pass
        else:
            print(eachitem)
            pass
        pass
    else:
        return
    pass

# 调用搜索文件夹对象
findFile('D:\\Study\\computer\\Python演示文档')