每日一题算法：K个一组翻转链表reverseKGroup2020.5.16

2020.5.16 K个一组翻转链表reverseKGroup

提供的格式

/**
 * 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) {

    }
}

思路分析

感觉很简单啊，遍历一遍不就可以了吗？画一个思路图吧

我们把第2-k的下一个改成上一个，然后把第1个的下一个改成第k个的下一个，同时加上一些长度的验证就应该能够实现。

试试，试的时候发现了很多的问题，一再地调试修改，问题越来越多，需要验证的元素越来越多，最后好不容易修改好了放在leecode上却跑不了，崩溃了，虽然这个算法很笨。

class Solution {
     
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode[] nodes=null;
        ListNode resultNode=null;
        while (true){
            nodes=new ListNode[k];

            for (int i=0;i<k;i++){
                if(i==0)
                    nodes[i]=head;
                else{
                    if (nodes[i-1]!=null)
                    nodes[i]=nodes[i-1].next;
                }
            }

            if (nodes[k-1]==null)
                break;

            //这个循环是用来给   长度%k=0时，最后一次的倒置时，第一个节点的下一个应该为空
            if (nodes[k-1].next==null){
                for(int i=1;i<k;i++)
                {
                        nodes[i].next=nodes[i-1];
                }
                nodes[0].next=null;
            }
            else {
                //默认下一次不用倒置，直接指向下一个链表开头
                nodes[0].next=nodes[k-1].next;
                //需要判断下一次需不需要倒置，如果需要那么指向最后一个，如果不需要，那就指向第一个

                ListNode node2=nodes[k-1].next;

                //先看看下一次能否到达尾部
                for (int j=0;j<k-1;j++)
                {
                    try{
                        node2=node2.next;
                    }catch (Exception e){
                        break;
                    }
                }
                //如果之前出错，那么node2肯定为空，node2如果不为空则证明下一个链的长度为k,然后判断node2的下一个是否为空
                head=nodes[0].next;
                
                if (node2!=null)
                    nodes[0].next=node2;
                //链表的倒置工作,之前判断过这次是否要倒置了，所以肯定需要倒置，直接倒置就可以了，从第2个开始
                for(int i=1;i<k;i++)
                {
                        nodes[i].next=nodes[i-1];
                }
            }
            if(resultNode==null){
                resultNode=nodes[k-1];
            }
            if(nodes[0].next==null)
                break;
        }

        if (resultNode==null)
            return head;
        else
            return resultNode;
    }
}

明天去查一查更简单的算法吧，今天就稍微休息一下。

想想不爽，回来检查了一下，是类名的原因导致的编译出错，把类名修改为默认的就可以了

然后修改了部分的代码终于通过了