反转链表,又可以称为翻转或逆置链表,它们表达的是同一个意思。以图 1 所示的链表为例:
![未反转的链表](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666485_0U23432Z-0.gif)
图 1 未反转的链表
经过反转(翻转、逆置)后,得到的新链表如图 2 所示:
![反转后的链表](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666513_0U2344062-1.gif)
图 2 反转后的链表
通过对比图 1 和 图 2 中的链表不难得知,所谓反转链表,就是将链表整体“反过来”,将头变成尾、尾变成头。那么,如何实现链表的反转呢?
## 1、迭代反转链表
该算法的实现思想非常直接,就是从当前链表的首元节点开始,一直遍历至链表的最后一个节点,这期间会逐个改变所遍历到的节点的指针域,另其指向前一个节点。
![迭代反转链表的初始状态](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666533_0U23460R-2.gif)
图 3 迭代反转链表的初始状态
在上图的基础上,遍历链表的过程就等价为:3 个指针每次各向后移动一个节点,直至 mid 指向链表中最后一个节点(此时 end 为 NULL )。需要注意的是,这 3 个指针每移动之前,都需要做一步操作,即改变 mid 所指节点的指针域,另其指向和 beg 相同。
![迭代反转链表过程一](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666515_0U2345228-3.gif)
图 4 迭代反转链表过程一
2) 在图 4 基础上,先改变 mid 所指节点的指针域指向,另其和 beg 相同(指向节点 1 ),再将 3 个指针整体各向后移动一个节点。整个过程如图 5 所示:
![迭代反转链表过程二](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666536_0U2343502-4.gif)
图 5 迭代反转链表过程二
3) 在图 5 基础上,先改变 mid 所指节点的指针域指向,另其和 beg 相同(指向节点 2 ),再将 3 个指针整体各向后移动一个节点。整个过程如图 6 所示:
![迭代反转链表过程三](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666515_0U2345331-5.gif)
图 6 迭代反转链表过程三
4) 图 6 中,虽然 mid 指向了原链表最后一个节点,但显然整个反转的操作还差一步,即需要最后修改一次 mid 所指节点的指针域指向,另其和 beg 相同(指向节点 3)。如图 7 所示:
![迭代反转链表过程四](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666506_0U23460G-6.gif)
图 7 迭代反转链表过程四
> 注意,这里只需改变 mid 所指节点的指向即可,不用修改 3 个指针的指向。
5) 最后只需改变 head 头指针的指向,另其和 mid 同向,就实现了链表的反转。
如下是实现整个过程的代码:
```java
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode ReverseList(ListNode head) {
if(head == null || head.next == null){
return head;
}
ListNode beg = null;
ListNode mid = head;
ListNode end = head.next;
//一直遍历
while (true)
{
//修改 mid 所指节点的指向
mid.next = beg;
//此时判断 end 是否为 NULL,如果成立则退出循环
if (end == null) {
break;
}
//整体向后移动 3 个指针
beg = mid;
mid = end;
end = end.next;
}
//最后修改 head 头指针的指向
head = mid;
return head;
}
}//时间复杂度:o(n),空间复杂度:o(1)
```
## 2. 递归反转链表
仍以图 1 中的链表为例,则整个递归实现反转的过程如下:
![递归反转链表过程一](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666516_0U2343055-7.gif)
图 8 递归反转链表过程一
2) 在此基础上,开始执行 17、18 行代码,整个操作过程如图 9 所示,最后将 new_head 的指向继续作为函数的返回值,传给上一层的 new_head。
![递归反转链表过程二](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666494_0U23413F-8.gif)
图 9 递归反转链表过程二
> 注意,图中节点 3 的 next 指针域`∧`表示为 NULL。
3) 再退一层,此时 new_head 仍指向节点 4,而 head 退出一层后,指向的是节点 2。在此基础上执行 17、18 行代码,并最终将 new_head 的指向作为函数返回值,继续传给上一层的 new_head。整个操作过程如图 10 所示:
![递归反转链表过程三](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666515_0U234D49-9.gif)
图 10 递归反转链表过程三
4) 再退一层,此时 new_head 仍指向节点 4,而 head 退出一层后,指向的是节点 1。在此基础上执行 17、18 行代码,并返回 new_head。整个操作过程如图 11 所示:
![递归反转链表过程四](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666503_0U2345454-10.gif)
图 11 递归反转链表过程四
head 由节点 1 进入递归,此时 head 的指向又返回到节点 1,整个递归过程结束。显然,以上过程已经实现了链表的反转,新反转链表的头指针为 new_head。
递归反转链表代码实现
```java
public ListNode ReverseList(ListNode head) {
if(head == null || head.next == null){
return head;
}else{
//一直递归,找到链表中最后一个节点
ListNode newHead = ReverseList(head.next);
//当逐层退出时,new_head 的指向都不变,一直指向原链表中最后一个节点;
//递归每退出一层,函数中 head 指针的指向都会发生改变,都指向上一个节点。
//每退出一层,都需要改变 head->next 节点指针域的指向,同时令 head 所指节点的指针域为 NULL。
head.next.next = head;
head.next = null;
//每一层递归结束,都要将新的头指针返回给上一层。由此,即可保证整个递归过程中,能够一直找得到新链表的表头。
return newHead;
}
}
```
## 3. 头插法实现反转数组
所谓头插法,是指在原有链表的基础上,依次将位于链表头部的节点摘下,然后采用从头部插入的方式生成一个新链表,则此链表即为原链表的反转版。
![创建一个空链表](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666534_0U2342546-11.gif)
图 12 创建一个空链表
2) 从原链表中摘除头部节点 1,并以头部插入的方式将该节点添加到新链表中,如图 13 所示:
![从原链表摘除节点 1,再添加到新链表中](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666503_0U2342R3-12.gif)
图 13 从原链表摘除节点 1,再添加到新链表中
3) 从原链表中摘除头部节点 2,以头部插入的方式将该节点添加到新链表中,如图 14 所示:
![从原链表摘除节点 3、4,再添加到新链表中](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666522_0U234C44-14.gif)
图 15 从原链表摘除节点 3、4,再添加到新链表中
由此,就实现了对原链表的反转,新反转链表的头指针为 new_head。
```java
public ListNode ReverseList(ListNode head){
if(head == null || head.next == null){
return head;
}
ListNode temp = null;
ListNode newHead = null;
while(head != null){
temp = head;
//将 temp 从 head 中摘除
head = head.next;
//将 temp 插入到 new_head 的头部
temp.next = newHead;
newHead = temp;
}
return newHead;
}
```
## 4、就地逆置法反转链表
就地逆置法和头插法的实现思想类似,唯一的区别在于,头插法是通过建立一个新链表实现的,而就地逆置法则是直接对原链表做修改,从而实现将原链表反转。
![就地反转链表的初始状态](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666510_0U2342L7-15.gif)
图 16 就地反转链表的初始状态
2) 将 end 所指节点 2 从链表上摘除,然后再添加至当前链表的头部。如图 17 所示:
![反转节点2](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666515_0U2341592-16.gif)
图 17 反转节点 2
3) 将 end 指向 beg->next,然后将 end 所指节点 3 从链表摘除,再添加到当前链表的头部,如图 18 所示:
![反转节点3](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666519_0U2343N4-17.gif)
图 18 反转节点 3
4) 将 end 指向 beg->next,再将 end 所示节点 4 从链表摘除,并添加到当前链表的头部,如图 19 所示:
![反转节点 4](https://uploadfiles.nowcoder.com/files/20200917/571302080_1600335666524_0U2342259-18.gif)
图 19 反转节点 4
由此,就实现了对图 1 链表的反转。
代码实现
```java
public ListNode ReverseList(ListNode head){
if(head == null || head.next == null){
return head;
}
ListNode beg = head;
ListNode end = head.next;
while (end != null) {
//将 end 从链表中摘除
beg.next = end.next;
//将 end 移动至链表头
end.next = head;
head = end;
//调整 end 的指向,另其指向 beg 后的一个节点,为反转下一个节点做准备
end = beg.next;
}
return head;
}
```
总结
本节仅以无头节点的链表为例,讲解了实现链表反转的 4 种方法。实际上,对于有头节点的链表反转:
* 使用迭代反转法实现时,初始状态忽略头节点(直接将 mid 指向首元节点),仅需在最后一步将头节点的 next 改为和 mid 同向即可;
* 使用头插法或者就地逆置法实现时,仅需将要插入的节点插入到头节点和首元节点之间即可;
* 递归法并不适用反转有头结点的链表(但并非不能实现),该方法更适用于反转无头结点的链表。