python链表的反转反转链表给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]
题解# definition for singly-linked list.# class listnode:# def __init__(self, val=0, next=none):# self.val = val# self.next = nextclass solution: """ 解题思路： 1.新建一个头指针 2.遍历head链表，依次在新的头节点位置插入，达到反转的效果 """ def reverselist(self, head: listnode) -> listnode: # 循环 new_head = none while head: per = head.next # pre 为后置节点，及当前节点的下一个节点 head.next = new_head # 插入头节点元素 new_head = head # 把串起来的链表赋值给头指针 head = per # 向后移一个单位 return new_head # 返回一个新的链表
python反转链表相关技巧给定一个单链表的头结点phead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。
要求：空间复杂度 o(1)o(1) ，时间复杂度 o(n)o(n) 。
输入：
{1,2,3}
返回值：
{3,2,1}
先来看最基本的反转链表代码：
# -*- coding:utf-8 -*-# class listnode:# def __init__(self, x):# self.val = x# self.next = noneclass solution: # 返回listnode def reverselist(self, phead): # write code here cur = phead pre = none while cur: nextnode = cur.next cur.next = pre pre = cur cur = nextnode return pre
关键公式抓住几个关键点：
cur：原链表的头节点，在反转结束时，cur指向pre的下一个节点
pre：原链表的尾节点，也就是反转后链表的头节点。最终返回的是pre。
while cur：表示反转循环的条件，这里是判断cur是否为空。也可以根据题目的条件改成其他循环条件
反转链表的尾节点，这里的尾节点是none，后面会提到显式指定。
对于反转链表的问题，抓住原链表的头节点、原链表的尾节点、反转循环条件、反转链表的尾节点这几个主要角色，基本没什么问题。
接下来，举两个例子：
链表内指定区间反转
链表中的节点每k个一组翻转
链表内指定区间反转将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 o(n)，空间复杂度 o(1)。
要求：时间复杂度 o(n) ，空间复杂度 o(n)
进阶：时间复杂度 o(n)，空间复杂度 o(1)
输入：
{1,2,3,4,5},2,4
返回值：
{1,4,3,2,5}
套用公式
这道题目和baseline的区别是，是将对整个链表的反转改成链表 m 位置到 n 位置之间的区间反转，来套一下公式：
原链表的头节点：cur：从head出发，再走m-1步，到达cur
原链表的尾节点：pre：cur前面的节点
反转循环条件：for i in range(n,m)
反转链表的尾节点：需要保存下从head出发，再走m-1步，到达cur时，此时pre的位置 prepos。prepos.next是反转链表的尾节点
和前面的比，需要额外注意下：
需要保存下从head出发，再走m-1步，到达cur时，此时pre的位置 prepos。在反转循环结束后，再进行穿针引线
由于不是对整个链表进行反转，最好新建虚拟头节点dummpynode，dummpynode.next指向整个链表
代码实现
先看下套公式部分的代码：
# 找到pre和curi = 1while i<m: pre = cur cur = cur.next i = i+1 # 在指定区间内反转prehead = prewhile i<=n: nextnode = cur.next cur.next = pre pre = cur cur = nextnode i = i+1
穿针引线部分代码：
nextnode = prehead.nextprehead.next = preif nextnode: nextnode.next = cur
完整代码：
class listnode: def __init__(self, x): self.val = x self.next = none class solution: def reversebetween(self , head , m , n ): # write code here dummpynode = listnode(-1) dummpynode.next = head pre = dummpynode cur = head i = 1 while i<m: pre = cur cur = cur.next i = i+1 prehead = pre while i<=n: nextnode = cur.next cur.next = pre pre = cur cur = nextnode i = i+1 nextnode = prehead.next prehead.next = pre if nextnode: nextnode.next = cur return dummpynode.next
链表中的节点每k个一组翻转将给出的链表中的节点每 k 个一组翻转，返回翻转后的链表
如果链表中的节点数不是 k 的倍数，将最后剩下的节点保持原样
你不能更改节点中的值，只能更改节点本身。
要求空间复杂度 o(1)，时间复杂度 o(n)
输入：
{1,2,3,4,5},2
返回值：
{2,1,4,3,5}
套用公式
这道题目和baseline的区别是，是将对整个链表的反转改成每k个一组反转，如果节点数不是k的倍数，剩下的节点保持原样。
先分段来看，假设面对位置1-位置k的链表：
原链表的头节点：cur：从head出发，再走k-1步，到达cur
原链表的尾节点：pre：cur前面的节点
反转循环条件：for i in range(1,k)
反转链表的尾节点：先定义tail=head，等反转完后tail.next就是反转链表的尾节点
先看下套公式部分的代码：
pre = nonecur = headtail = head i = 1while i<=k: nextnode = cur.next cur.next = pre pre = cur cur = nextnode i = i+1
这样，我们就得到了1 位置1-位置k的反转链表。
此时：
pre：指向反转链表的头节点
cur：位置k+1的节点，下一段链表的头节点
tail：反转链表的尾节点
那么，得到位置k+1-位置2k的反转链表，就可以用递归的思路，用tail.next=reverse(cur，k)
需要注意：如果链表中的节点数不是 k 的倍数，将最后剩下的节点保持原样
i = 1tmp = curwhile i<=k: if tmp: tmp = tmp.next else: return head i = i+1
代码实现
完整代码：
class listnode: def __init__(self, x): self.val = x self.next = none class solution: def reversekgroup(self , head , k ): # write code here return self.reverse(head, k ) def reverse(self , head , k ): pre = none cur = head tail = head i = 1 tmp = cur while i<=k: if tmp: tmp = tmp.next else: return head i = i+1 i = 1 while i<=k: nextnode = cur.next cur.next = pre pre = cur cur = nextnode i = i+1 tail.next = self.reverse(cur, k) return pre
好了，抓住几个关键点：
cur：原链表的头节点，在反转结束时，cur指向pre的下一个节点
pre：原链表的尾节点，也就是反转后链表的头节点。最终返回的是pre。
while cur：表示反转循环的条件，这里是判断cur是否为空。也可以根据题目的条件改成其他循环条件
反转链表的尾节点，这里的尾节点是none，后面会提到显式指定。
以上就是python链表的反转方式是什么的详细内容。