【LeetCode 206. 反转链表】——链表，迭代法，递归法

最新推荐文章于 2023-05-18 11:08:33 发布

木瓜星灵TT

最新推荐文章于 2023-05-18 11:08:33 发布

阅读量136

点赞数 2

分类专栏： LeetCode学习笔记文章标签：链表 leetcode 数据结构算法 c++

本文链接：https://blog.csdn.net/weixin_51630192/article/details/126534882

版权

LeetCode学习笔记专栏收录该内容

37 篇文章 0 订阅

订阅专栏

206. 反转链表：

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

**进阶：**链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

思考：

链表的翻转也属于是链表的一种基本操作。而具体的实现方式，其实就是改变链表中每个结点指向的next结点。所以我们可以用迭代法和递归法这两种方法来实现，其本质其实是一样的。

迭代法：

定义三种指针preNode、currentNode、next进行迭代操作。直至最后一位。

//Definition for singly-linked list.
 struct ListNode {
     int val;
     ListNode *next;
     ListNode() : val(0), next(nullptr) {}
     ListNode(int x) : val(x), next(nullptr) {}
     ListNode(int x, ListNode *next) : val(x), next(next) {}
 };
 
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* preNode = nullptr; //前向前结点的指针
        ListNode* currentNode = head; //当前指针

        while (currentNode) //进行迭代操作
        {
            ListNode* next = currentNode->next;//指向后结点的指针
            currentNode->next = preNode; //原本指向后面，现在指向前面
            preNode = currentNode; //移动前指针
            currentNode = next; //移动当前指针至下一位
        }
        return preNode;
    }
};

递归法：

在迭代法的基础上，简化算法，运用递归的思想，而不是使用循环。在一开始时，要对链表进行讨论，是否为空链表，此时返回空。而递归的结束条件则为，head->next为空，即已经遍历到了最后一位。

//Definition for singly-linked list.
 struct ListNode {
     int val;
     ListNode *next;
     ListNode() : val(0), next(nullptr) {}
     ListNode(int x) : val(x), next(nullptr) {}
     ListNode(int x, ListNode *next) : val(x), next(next) {}
 };
 
class Solution {
public:
    ListNode* reverseList2(ListNode* head) {
        // 边缘条件判断
        if (head == NULL) return NULL;
        if (head->next == NULL) return head;

        // 递归调用，翻转第二个节点开始往后的链表
        ListNode* last = reverseList(head->next);
        // 翻转头节点与第二个节点的指向
        head->next->next = head;
        // 此时的 head 节点为尾节点，next 需要指向 NULL
        head->next = NULL;
        return last;
    }
};

其他：

值得一提的是，对于我们之前提到的含有虚拟头结点的链表，若要进行翻转，我们要将那个虚拟头结点始终置于头部，若使用上述方法，原本的虚拟头指针会变成最后一位，成为虚拟尾指针。

所以我们可以使用下述方法：

//链表逆置
List Inverse(List L)
{
	List p, q;
	p = L->Next;     //p指针指向第一个结点
	L->Next = NULL;  //头结点指向NULL

	while (p != NULL) {
		q = p;
		p = p->Next;
		q->Next = L->Next;
		L->Next = q;
	}
	return L;
}