5.链表：递归打印链表

核心：递归

入栈为递，出栈为归。栈的先入后出

#include <stdlib.h>
#include <stdio.h>

struct Node
{
    int data;
    struct Node *next;
};

struct Node *Insert(struct Node *head, int data)
{
    struct Node *Temp = (struct Node *)malloc(sizeof(struct Node));
    if (Temp == NULL)
    {
        printf("Memory allocation failed\n");
        return NULL; // 检查内存分配
    }
    Temp->data = data;
    Temp->next = NULL;

    if (head == NULL)
    {
        head = Temp; // 如果链表为空，直接将头指针指向新节点.修改了头指针，所以要返回
    }
    else
    {
        struct Node *current = head; // 使用临时指针遍历链表
        while (current->next != NULL)
        {
            current = current->next;
        }
        current->next = Temp; // 将新节点插入到链表末尾
    }
    return head;
}

struct Node *Delete(struct Node *head, int n)
{
    struct Node *Temp = head;
    if (Temp == NULL)
    {
        printf("Memory allocation failed\n");
        return NULL; // 检查内存分配
    }

    if (n == 1)
    {
        head = Temp->next;
        free(Temp);
        return head;
    }

    int i;
    for (i = 0; i < n - 2; i++) // 大于2,才往后移动
        Temp = Temp->next;

    struct Node *Temp2 = Temp->next;
    Temp->next = Temp2->next;
    free(Temp2);
    return head;
}

void Print(struct Node *head)
{
    // 逆序打印，满足条件后返回上一个的执行结果
    if (head == NULL)
        return;                // 递归退出条件
    Print(head->next);         // 递归循环开始,创建栈帧
    printf("%d ", head->data); // 达到递归退出条件后,再从顶层栈帧往Print(head->next)语句后执行

    // 顺序打印，执行一次递归打印一次
    if (head == NULL)
        return;                // 递归退出条件
    printf("%d ", head->data); // 正常执行语句
    Print(head->next);         // 递归循环开始,创建栈帧。
    // 达到递归退出条件后,再从顶层栈帧往Print(head->next)语句后执行
}

struct Node *Reverse(struct Node *head)
{
    struct Node *current, *prev, *next; // 当前值、上一个、下一个

    current = head;         // 将头节点给当前值
    prev = NULL;            // 将上一个值赋值为NULL
    next = NULL;            // 将下一个值赋值为NULL
    while (current != NULL) // 如果当前值后面还有值
    {
        next = current->next; // 使用next保存后面的值
        current->next = prev; // 砍断与下一个值的联系，并把它连接在prev上
        prev = current;       // 更新反转链表的当前指向
        current = next;       // 将下一个值给用作当前值
    }
    head = prev; // 将头节点指向反转的链表
}

int main()
{
    struct Node *head = NULL;
    // 插入
    head = Insert(head, 1);
    head = Insert(head, 2);
    head = Insert(head, 3);
    head = Insert(head, 4);

    // 删除
    // head = Delete(head, 1);

    // 反转
    // head = Reverse(head);

    // 打印
    Print(head);
    return 0;
}

核心一.

核心思想：创建栈帧，直至达到退出递归条件。退出后最再从上到下一个个出栈，执行函数

    // 逆序打印，满足条件后返回上一个的执行结果
    if (head == NULL)
        return;                // 递归退出条件
    Print(head->next);         // 递归循环开始,创建栈帧
    // 达到递归退出条件后,再从顶层栈帧往Print(head->next)语句后执行
    printf("%d ", head->data);

核心二.

核心思想：创建栈帧之前，就开始执行函数，最后再从上到下一个个出栈

    // 顺序打印，执行一次递归打印一次
    if (head == NULL)
        return;                // 递归退出条件
    printf("%d ", head->data); // 正常执行语句
    Print(head->next);         // 递归循环开始,创建栈帧。
    // 达到递归退出条件后,再从顶层栈帧往Print(head->next)语句后执行

核心三.

普通遍历函数，一个个打印，就在一个栈帧上操作

void Print(struct Node *head)
{
    struct Node *temp = head;
    printf("List is ");
    while (temp != NULL)
    {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

结语

1.递归是时间换空间，要额外创建栈帧，消耗栈空间。递归次数过多会栈溢出程序崩溃。

2.所以一般是使用普通函数遍历，在单个栈帧上操作

3.为什么使用递归？简化代码，苦逼机器。