Leetcode 206/92/24链表翻转系列

206. 翻转链表

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

 tips：该题是基础题，维护三个变量即可，pre，cur，next。先读取next，然后再讲cur的指针指向pre。然后更新pre与cur。在切断链表时，一定要先保存切断节点的下一个节点。代码如下：

# 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:
        p_pre = None
        p_cur = head
        while p_cur:
            p_next = p_cur.next
            p_cur.next = p_pre
            p_pre = p_cur
            p_cur = p_next     
        return p_pre

92 翻转链表Ⅱ

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。

说明:
1 ≤ m ≤ n ≤ 链表长度。

示例:

输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL

tips：本题给定固定区间进行链表翻转，找出起始与截止位置即可。但是需要分析起始节点是否为首节点。为了简化操作，引入新的首节点，避免分类讨论。一次遍历的代码如下：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
        if m==n:
            return head
        new=ListNode(0)
        new.next=head
        node1=new #m-1节点初值
        node2=None #n+1节点初值
        cnt=1
        #查找起始节点位置
        while cnt<m:
            node1=head#存储开始翻转前一个节点
            head=head.next
            cnt+=1
        #翻转m到n的节点们
        pre=None
        cur=head
        reversed_end=cur#存储翻转后的末尾节点
        while cnt<=n:
            nex=cur.next
            cur.next=pre
            pre,cur=cur,nex
            cnt+=1
            node2=cur#存储翻转结束后的下一个节点
        node1.next=pre#将翻转后的链表链入前半段原始链表中
        reversed_end.next=node2#将后半段原始链表链入
        return new.next#返回除去新添加节点的链表
        
        # 下面方法复杂一些，一次遍历找到起始与截止节点后，再次遍历翻转
        # cnt=0
        # node=new
        # node1=new
        # node2=None
        # while node:
        #     if cnt==m-1:
        #         node1=node
        #     if cnt==n+1:
        #         node2=node
        #         break
        #     node=node.next
        #     cnt+=1
        # pre=node2
        # cur=node1.next
        # while cur and cur!=node2:
        #     nex=cur.next
        #     cur.next=pre
        #     pre,cur=cur,nex
        # node1.next=pre
        # return new.next

24. 两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

 

示例:

给定 1->2->3->4, 你应该返回 2->1->4->3.

tips： 方法一，仅交换两个节点的值。代码如下：

    def main(head)
        #仅交换节点的值         
        if not head:
            return 
        phead=head
        while head and head.next:
            head.val,head.next.val=head.next.val,head.val
            head=head.next.next
        return phead

方法二：找规律，引入辅助头节点，每次我们只交换两个节点，需要读取三个next节点。分别命名为node1，node2，node3（rear）节点。交换完成后，将cur节点更新为node1节点即刻循环迭代执行下去。

 

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        if not head:
            return 
        #构建辅助起始节点
        new=ListNode(0)
        #注意链接到原始链表中
        new.next=head
        
        cur=new
        while cur and cur.next and cur.next.next:
            node1=cur.next
            node2=node1.next
            node3=node2.next
            cur.next=node2
            node2.next=node1
            node1.next=node3
            cur=node1
        return new.next