算法练习--k个一组翻转链表

题目：

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例：

给你这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

个人思路：

我的解法有两种，代码中注释的是一种，没注释的是另一种，我介绍没注释的思路

用一个大小为k的数组存储要翻转的节点，然后将它们翻转，用一个尾指针指向翻转后的尾节点，这样就可以连接下次新的翻转链表了，当第一次翻转时，用头指针指向翻转链表的头节点，以便返回。

代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        // ListNode re=null;
        // ListNode end1=null;
        // int end1_val=1;
        // ListNode end2=null;
        // int end2_val=1;
        // ListNode pre=null;
        // ListNode nex=null;

        // int length=0;
        // ListNode h=head;
        // while(h!=null){
        //     h=h.next;
        //     length++;
        // }

        // while(head!=null&&length-k>=0){
        //     for(int i=0;i<k&&head!=null;i++){
        //         length--;
        //         nex=head.next;
        //         head.next=pre;
        //         pre=head;
        //         if(i==0){
        //             if(end1_val==1){
        //                 end1=pre;
        //             }
        //             if(end2_val==1){
        //                 end2=pre;
        //             }
        //         }
        //         head=nex;
        //     }
        //     if(re==null){
        //         re=pre;
        //         end1_val=0;
        //     }else{
        //         if(end1_val==0){
        //             end1_val=1;
        //             end1.next=pre;
        //             end2_val=0;
        //         }else{
        //             end2_val=1;
        //             end2.next=pre;
        //             end1_val=0;
        //         }
        //     }
        //     pre=null;
        // }

        // if(end1_val==0){
        //     end1.next=head;
        // }else{
        //     end2.next=head;
        // }
        // return re;
        // *******************************************************
        int length=0;
        ListNode h=head;

        //计算链表长度
        while(h!=null){
            h=h.next;
            length++;
        }

        //存储每k个的链表，用来翻转
        ListNode[] l=new ListNode[k];

        //链表的头指针，用来返回
        ListNode re=null;
        //链表的尾指针，用来连接后面加入的链表
        ListNode end=null;

        //遍历，只要链表长度还大于k
        while(head!=null&&length-k>=0){
            //将k个节点放入数组，进行翻转
            for(int i=0;i<k;i++){
                l[i]=head;
                head=head.next;
                length--;
                //第一个放入数组的翻转后是最后一个，所以next为空
                if(i==0){
                    l[i].next=null;
                }else{
                    l[i].next=l[i-1];
                }
            }

            //判断是不是第一个k数组，如果是（即re还为空时），记录头指针和尾指针
            if(re==null){
                re=l[k-1];
                end=l[0];
            }else{
                //不是第一个k数组，尾指针添加新的k数组链表，更新尾指针
                end.next=l[k-1];
                end=l[0];
            }   
        }
        //尾指针连接无法翻转的链表
        end.next=head;
        return re;
    }
}