线性链表 反转 -(递归与非递归算法)_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 模式,这种模式就是通过栈接力,直至把最初的值传递给最后出栈的函数。
参考资料:
《数据结构》清华大学,严蔚敏