线性链表 反转 -(递归与非递归算法)_20230420
- 前言
线性链表反转是非常有趣的算法，它可以采用多种方式实现，比较简洁的方法是递归反转；传统的方式是利用迭代反转，设定三个变量，采用类似滚动数组的方式，实现线性表的反转；利用线性表头部插入方法也不失为一种直观有效的方式，这种情况下需要重新建立线性链表，在遍历目标链表的同时，不断把元素插入新的线性链表的头部，从而实现反转；最后的方式是就地反转，不用设定新的线性链表，在本身线性链表的基础之上，实现元素的反转，这种方式与头插法类似，过程中需要至少三个变量保存链表的头部，待处理结点和链表的尾部。
具体看一个实际例子。假定给到下图的线性链表，要求通过合适的算法，实现线性链表的反转。反转前链表结构，
反转的过程本质上不是重新建立结点的过程，而是重新链接其next结点以及设定新的头结点的过程，这个过程中结点地址和内容本身不会发生变化，发生变化的是结点中的next指针域和头结点的位置。通过一系列的算法操作，重新建立next链接后的线性链表实现了反转。
- 线性表反转不同算法实现
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;
}
- 小结
通过线性链表反转练习，复习了线性链表的基本结构，同时通过递归和非递归算法的对比，体现出递归模式的优雅和代码的简洁，本次递归过程中学习了返回值的propagation 模式,这种模式就是通过栈接力，直至把最初的值传递给最后出栈的函数。
参考资料：
《数据结构》清华大学，严蔚敏
