leetcode链表-反转链表-leetcode206、leetcode92、leetcode25、leetcode61、leetcode24

leetcode206-反转链表：反转链表节点的指向

（1）一个指针cur记录待翻转节点，一个节点pre记录翻转后的链表头节点，在反转过程中还需记录待反转节点的后继节点tail

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if not head or not head.next: return head
        pre = None
        cur = head
        while cur:
            tail = cur.next
            cur.next = pre
            pre = cur 
            cur = tail

        return pre

while循环中

（1）先记录待反转节点cur的后继节点tail

（2）改变cur.next的指向反转链表头节点pre

（3）改变反转链表头节点

（4）改变待反转的节点

---

leetcode92-反转链表2：反转链表多了需要反转的位置限制

反转链表的函数，限制反转的个数，并将反转好的部分和其余部分进行拼接

class Solution:

    def reverseN(self, head, n):

        pre = None
        cur = head

        for i in range(n):
            tail = cur.next
            cur.next = pre
            pre = cur
            cur = tail
        
        head.next = cur
        return pre

    def reverseBetween(self, head: ListNode, left: int, right: int) -> ListNode:
        if not head or not head.next or left == right: return head

        empty = ListNode(0)
        empty.next = head
        p = empty
        for _ in range(left-1):
            p = p.next
        p.next = self.reverseN(p.next, right - left + 1)

        return empty.next

---

leetcode25-K个一组反转链表：K个一组反转链表，不满K个节点的部分不反转

在上一题的基础上，多加一个指针q来探路，不满K个节点就返回。满K个节点就反转，注意这里p节点用来接反转后的链表，所以每次接了反转后的链表部分，也要跟着后移哦

class Solution:

    def reverseN(self, head, n):
        pre = None
        cur = head
        for _ in range(n):
            tail = cur.next
            cur.next = pre
            pre = cur
            cur = tail
        head.next = cur
        return pre

    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        empty = ListNode(0)
        empty.next = head
        p = empty
        while True:
            q = p
            for _ in range(k):
                if not q.next:
                    return empty.next
                q = q.next
            p.next = self.reverseN(p.next, k)
            for _ in range(k):
                p = p.next
        return empty.next

---

leetcode24-两两交换节点

（1）可视作上一题k=2的特殊情况

（2）直接交换来解

class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        if not head or not head.next: return head

        empty = ListNode(0, head)
        pre = empty
        while pre.next and pre.next.next:
            node1 = pre.next
            node2 = pre.next.next
            node3 = node2.next
            pre.next = node2
            node2.next = node1
            node1.next = node3
            pre = node1
        return empty.next

---

leetcode61-旋转链表：向右旋转K个位置

把链表添加一条边变成环，找到合适位置把链表断开就OK了

class Solution:
    def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        if not head or not head.next or k == 0: return head
        count = 1
        pre = head
        while pre.next:
            pre = pre.next
            count += 1
        shift = k % count #取个余，减少计算量
        if shift == 0:
            return head
        pre.next = head
        p = head
        for _ in range(count - shift - 1): 
            p = p.next
        newhead = p.next
        p.next = None 
        return newhead