反转链表
1.原地操作（三指针法）
这种算法其实跟头插法的主要区别是，这种反转尽可能的在自身进行操作
如果我们的链表是H-1-2-3-4-5
H-2-1-3-4-5
H-3-2-1-4-5
发现了吗？我们操作的指针一个在P处，一个在1处，这就是为什么我们要定义三个指针（如果有头指针只定义两个）：
因为咱们要保存H的位置，1还有1之后的位置，如果你把1直接跳过之后的位置指向3，那么你的2就再也找不回来了。
从H开始原地操作，最终变成H-5-4-3-2-1
这时候H作为头节点，H之后的链表不断翻滚，返回的是H.next
但是如果咱们的链没有头节点1-2-3-4-5-6，此时返回的是1-6-5-4-3-2
最简单的办法就是直接自己加一个头节点
我在leetcode上的反转链表就是如此操作，代码如下：
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
if not head:
return None
r=ListNode(0)
r.next=head
p=head
q=head.next
while q:
p.next=q.next
q.next=r.next
r.next=q
q=p.next
return r.next
这种操作方法还有一个好处是可以在一个链表中某段进行操作，主要就是r的定义，咱们定义的r.next=head，循环条件是while q，如果我们只需要循环一部分比如说h-1-3-4-5-w-4-5-6-o-3-4-5，我们要操作w和o之间的逆，只要把w作为r，while q!=o，这样只要没有重复元素，就可以把wo之间的链表反转且不影响链表整体。
2.头插法
除了直接操作还有一种头插法，这种方法就是定义一个新的头节点，这种适合要把链表单独拎出来的情况。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
if not head:
return None
new=ListNode(0)
while head:
p=head.next
head.next=new.next
new.next=head
head=p
return new.next
其实你发现逻辑跟第一种方法非常类似，是拿到head第一个节点，然后给new，p的作用就是为了临时存储一下head的下一个节点，要不然head走了以后就再也找不到这个链表了。
3.递归法
其实单纯讲理解，我个人觉得递归是最容易理解的方法，很简单就是A和B如果想对调，那就很简单直接对调就好了变成BA，但是如果ABC想对调就不能如此简单，因为如果A和BC对调了，就变成BC A，你会发现这个时候BC内部还是没有对调，那怎样，直接对调BC，如果你把C再细分成CD，那就再对调CD！
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
if not head or not head.next:
return head
m=self.reverseList(head.next)
head.next.next=head
head.next=None
return m
这段代码最容易出错的地方就在于是head.next.next=head，容易写成m.next=head，m.next这种写法在第一次操作没什么问题，当递归到第二次你就会发现他把中间的数值都“吃”了。原因就在于m一直指向的是反转后的链表的第一个元素，我们要做的其实是不断把反转后的链表的前面第一个元素运到后面，那如何找到最后呢，就是head和之前那个元素保持的联系。
比如1-2-3-4-5
一次操作1-2-3 5-4
此时3其实还是指向4的而不是指向了5
所以直接head.next.next=head
就把3拉到4的后面了。