链表节点每k个一组翻转

通过迭代翻转指针，首先是当前指针直接指向下一个的下一个指针，然后下一个指针指向头指针（注意是头指针）也就是pre.next，然后pre再指向它。相当于将当前指针与下一个下一个指针。然后看链表的长度是多少count，这样的反转进行count/k次，反转时的指针变换一共会进行k-1次，所以range(1,k)
边界条件有head 为None head.next为None k为1的时候。

class Solution:
    def reverseKGroup(self , head , k ):
        # write code here
        if head==None or head.next==None or k==1:
            return head
        l=head
        cur=head
        count=0
        res=ListNode(0)
        res.next=head
        pre=res
        nextnode=None

        while l!=None:
            count+=1
            l=l.next

        for i in range(count/k):
            for j in range(1,k):
                nextnode=cur.next
                cur.next=nextnode.next

                nextnode.next=pre.next#注意nextnode节点折回去应该指向头节点
                pre.next=nextnode
            pre=cur
            cur=cur.next

        return  res.next

使用栈,根据k，将链表放入栈中然后读出就可以反转，进行count/k次，结束后连接正常链表的l节点（后半段）
也可以直接入栈节点，这样不用后面再新建节点。

class Solution:
    def reverseKGroup(self , head , k ):
        # write code here
        if head==None or head.next==None or k==1:
            return head
        n=head
        stack=[]
        count=0
        result=res=ListNode(0)
        while n!=None:
            count+=1
            n=n.next
        l=head
        for i in range(count/k):
            t=k
            while t>0:
                stack.append(l.val)
                l=l.next
                t-=1
            while stack:
                res.next=ListNode(stack.pop())
                res=res.next
        res.next=l
        return result.next

通过递归方法，设计一个递归函数为翻转链表，参数为翻转部分的头和尾，然后通过k定位循环，来找到要反转部分的尾，翻转函数通过挪指针，然后将剩下的部分再进行k个一组的翻转，再将两个部分连接起来。当剩余部分不足k个的时候，直接返回head即不进行翻转。

class Solution:
    def reverseKGroup(self , head , k ):
        # write code here
        def reverse(start,end):

            nextnode=pre=None
            cur=start
            while cur!=end:
                nextnode=cur.next
                cur.next=pre 
                pre=cur
                cur=nextnode
            return pre

        if head==None or head.next==None:
            return head

        tail=head
        i=0
        while i<k and tail!=None:
            tail=tail.next
            i+=1
        if i==k:

            reverse_result=reverse(head,tail)
        else:
            return head

        other_result=self.reverseKGroup(tail, k)

        head.next=other_result

        return reverse_result