数据结构算法刷题（22）反转链表

思路一：使用循环，利用三个指针，每次将cur的next指向pre，然后将pre修改到cur，cur修改到nxt，nxt后移指针。知道cur为空，返回pre。

 

class Solution:

    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:

        #用三个指针，pre指向当前节点的前一个节点，cur指向当前节点，nextcur指向当前节点的后一个节点

        if not head:

            return head

        pre = None

        cur = head

        nextcur  = head.next

        while cur:

            cur.next = pre

            pre = cur

            cur = nextcur

            if nextcur:

                nextcur = nextcur.next

        return pre 

思路二：利用递归：

class Solution:

    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:

        #利用递归

        if head is None or head.next is None: #跳出递归的条件

            return head

        p = self.reverseList(head.next)

        head.next.next = head

        head.next = None #用两个节点的链表模拟一下就知道递归到最后俩节点应该怎么做

        return p

思路：首先找到left的前一个节点（为了避免left是头结点，所以我们给头结点之前再加一个节点），然后反转（right-left+1）个节点，反转方式如上，最后，修改这段数据前的指针。

class Solution:

    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:

        dummy = ListNode(next=head) #在头结点之前加一个节点

        p0 = dummy

        for _ in range(left-1):

            p0 = p0.next #先找到left的前一个节点

        pre = None

        cur = p0.next

        for _ in range(right-left+1): #反转到right节点,cur最后指向right+1的节点

            nextcur = cur.next

            cur.next = pre

            pre = cur

            cur = nextcur

        p0.next.next = cur

        p0.next = pre

        return dummy.next #不能返回head，因为此时head可能已经被反转到了其他地方。

思路：先求出链表的长度，当n>=k的时候，可以反转，反转从left= 1开始，每次反转k个节点，反转之后，更新p0的值（下一次反转的前一个节点），让前后连接。

class Solution:

    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:

        #首先求出链表的长度，保证可以反转

        p = head

        n = 0

        while p:

            n += 1

            p = p.next

        #对于每一个k，进行一次反转，每次反转之后再将p0修改

        dummy = ListNode(next = head)

        p0 = dummy

        cur = p0.next #从链表的第一个开始反转

        pre = None

        while n >= k:

            n -= k

            for _ in range(k): #反转k个值

                nextcur = cur.next

                cur.next = pre

                pre = cur

                cur = nextcur

            nxt = p0.next #记录下当前的p0.next

            p0.next.next = cur #让反转之后的最后一个节点与后续节点连接

            p0.next = pre #连接在cur现在的（反转前）前一个节点上

            p0 = nxt #下一次反转的left的前一个节点

        return dummy.next

 

class Solution:

    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:

        #求链表的长度

        n = 0

        p = head

        while p:

            n += 1

            p = p.next

        #对链表进行节点反转

        dummy = ListNode(next=head)

        p0 = dummy

        cur = p0.next

        pre = None

        while n >= 2:

            n -= 2

            for _ in range(2):

                nextcur = cur.next

                cur.next = pre

                pre = cur

                cur = nextcur

            nxt = p0.next

            p0.next.next = cur

            p0.next = pre

            p0 = nxt

        return dummy.next