线性链表 反转 -(递归与非递归算法)_20230420

线性链表 反转 -(递归与非递归算法)_20230420

1. 前言

线性链表反转是非常有趣的算法，它可以采用多种方式实现，比较简洁的方法是递归反转；传统的方式是利用迭代反转，设定三个变量，采用类似滚动数组的方式，实现线性表的反转；利用线性表头部插入方法也不失为一种直观有效的方式，这种情况下需要重新建立线性链表，在遍历目标链表的同时，不断把元素插入新的线性链表的头部，从而实现反转；最后的方式是就地反转，不用设定新的线性链表，在本身线性链表的基础之上，实现元素的反转，这种方式与头插法类似，过程中需要至少三个变量保存链表的头部，待处理结点和链表的尾部。

具体看一个实际例子。假定给到下图的线性链表，要求通过合适的算法，实现线性链表的反转。反转前链表结构，

反转的过程本质上不是重新建立结点的过程，而是重新链接其next结点以及设定新的头结点的过程，这个过程中结点地址和内容本身不会发生变化，发生变化的是结点中的next指针域和头结点的位置。通过一系列的算法操作，重新建立next链接后的线性链表实现了反转。

2. 线性表反转不同算法实现

2.1.线性链表建立

递归算法之前，需要先建立简单的线性链表，线性链表一般由两部分沟通，两个域分别包含数据和指向下一结点的指针。Value域存放数据对象，next域存放指针，指针指向下一个结点。

链表的建立通过函数build_linked_list实现，具体模式采用尾部插入方法，如果链表为空，那么就作为链表的头结点，否则通过循环寻找需要插入位置的前置结点，然后把前置结点的next指向待插入结点即可（p->next = new_ptr)。

建立链表的具体算法实现，

typedef struct Link_Node
{
    int value;
    struct Link_Node * next;
}Link_Node, *Linked_Elem;

void make_node(Linked_Elem *node, int val)
{
    *node=(Linked_Elem)malloc(sizeof(Link_Node));
    (*node)->value=val;
    (*node)->next=NULL;
}

void build_linked_list(Linked_Elem *list, int val)
{
    Linked_Elem p;
    Linked_Elem new_ptr;

    make_node(&new_ptr, val);

    if(*list==NULL)
    {
        *list=new_ptr; 
    }
    else
    {
        p = *list;

        while (p->next != NULL)
        {
            p = p->next;
        }

        p->next = new_ptr;
    }

    return;
}

2.2 递归算法

首先介绍简洁而优雅的递归算法，递归算法秉承”大事化小，小事化了“的算法理念，最终把问题分而治之，递归的关键是找到子问题，那么寻找线性表反转的子问题就成为解决问题的核心与关键。递归的子问题可以通过迭代，不断缩小线性链表的元素规模。

通过不断向后移动线性表中的元素位置，达到缩小线性表规模的目的。当子问题中仅包含单个元素或原问题本身为空集，此时就构成递归算法的base返回基础的情况。

当问题规模缩小满足递归出口条件时候，函数就进入出栈操作流程。

递归入栈过程，

递归出栈过程，

递归的出栈后，实际上仅包含两个操作语句，首先是head->next->next=head，此时对head的next域的next域进行赋值，赋值到其本身，它形成一个环，然后利用语句head->next=NULL, 隔断环的结构。随着不断出栈，那么就形成了从后一元素指向前一元素的线性链表。

递归过程的难点之一是如何保存反转后链表的头指针，这就需要用到递归扩展(propagation)的基本概念，简单做法就是，在第一次出栈之前，逐步递归返回第一次出栈的元素，也即是相同的首元素不断出栈，不断把值传递给下一个栈，通过return 不断返回当前栈里面指针，给到下一个栈。

具体的代码实现，

Linked_Elem reverse_linked_list_recursion(Linked_Elem head)
{
    Linked_Elem p;

    if(head==NULL || head->next==NULL)
    {
        return head; //keep head by each frame stack
    }
    else
    {
        p=reverse_linked_list_recursion(head->next); //keep returned pointer
        head->next->next=head;//operation on the parameters of function
        head->next=NULL;//operation on the parameters of function
        return p; //return head by each frame stack
    }
}

2.3 迭代方法

迭代方法采用从线性表头至尾部的的遍历，其本质是对两个结点之间的连接关系进行反转，从最简单的两个元素线性表分析，我们可以看到，只需要把后一个线性表的next指针指向前一个结点，前一个结点的next指针域置空后就满足反转的要求。

如果线性链表中的元素超过两个，那么问题就来了，邻接元素的next域指向前一个元素之后，就无法再遍历后续的元素。这时候滚动数组的概念应运而生。

具体看实际例子，设定指针start, end 和temp, 每次对start 和end的指针关系进行倒置，同时用temp指针保存倒置之前的end下一个结点，然后这三个结点指针整体往前移动1位，重复上述操作。

代码实现

Linked_Elem reverse_linked_list_iteration(Linked_Elem head)
{
    Linked_Elem start;
    Linked_Elem end;
    Linked_Elem temp;

    start=head;
    end=start->next;
    start->next=NULL;

    while(end)
    {
        temp=end->next;
        end->next=start;
        start=end;
        end=temp;        
    }

    return start;
}

2.3 头部插入法

头插法和尾插法实际上是建立线性链表的两种常规的方式，由于题目要求倒置，所以需要从头到尾在线性遍历的同时采用头部插入法，如果采用尾插法，那么就相当于复制一个相同的线性表。

头部插入法的具体实现为，建立一个临时头部结点，同时开始遍历原线性链表，先遍历后插入,最后返回临时头部结点的next域。

代码实现

Linked_Elem reverse_linked_list_head_insertion(Linked_Elem head)
{
    Linked_Elem temp_head;
    Linked_Elem p;
    Linked_Elem q;

    temp_head=(Linked_Elem)malloc(sizeof(Link_Node));
    temp_head->next=NULL;
    p=head;

    while(p)
    {
        q=p->next;
        p->next=temp_head->next;
        temp_head->next=p;
        p=q;
    }

    return temp_head->next;
    
}

2.4 原线性表就地反转法(in-place reversal)

对原有线性表进行反转，无需建立额外线性表，反转完成后，原来线性表当中的自动形成一个线性反转链表。这个方法的巧妙之处在于，它通过参数中的head指针，以及额外的start和end指针就可以实现就地反转，可以形象称之为“就地翻筋斗”。

以具体实现流程介绍（部分），它实际上先隔离end结点，用start->next指针进行保存，实际上start->next指针在程序执行过程中它的位置保持不变，主要作用是记录下一个待处理的结点。end->next=head表明，重新进行反转链接的操作，而后更新head的位置，指向新的end, 最后把end移动到新的待处理的结点，这时候一个循环周期完成，直至迭代直至所有结点遍历结束。

代码实现

Linked_Elem reverse_linked_list_in_place(Linked_Elem head)
{
    //It is hard in understanding the reverse in place
    Linked_Elem start;
    Linked_Elem end;

    start=head;
    end=start->next;

    while(end)
    {
        start->next=end->next; // Isolate the end and keep its next in start's next
        end->next=head; //link end with old head
        head=end;  // move old head to new head(end pointer)
        end=start->next; // move end to next to be processed target
    }

    return head;
}

3. 小结

通过线性链表反转练习，复习了线性链表的基本结构，同时通过递归和非递归算法的对比，体现出递归模式的优雅和代码的简洁，本次递归过程中学习了返回值的propagation 模式,这种模式就是通过栈接力，直至把最初的值传递给最后出栈的函数。

参考资料：

《数据结构》清华大学，严蔚敏