字节跳动笔试题-链表

# 题目

 这其实是一道变形的链表反转题，大致描述如下给定一个单链表的头节点 head,实现一个调整单链表的函数，使得每K个节点之间为一组进行逆序，并且从链表的尾部开始组起，头部剩余节点数量不够一组的不需要逆序。（不能使用队列或者栈作为辅助）

例如：
链表:1->2->3->4->5->6->7->8->null, K = 3。那么 6->7->8，3->4->5，1->2各位一组。调整后：1->2->5->4->3->8->7->6->null。其中 1，2不调整，因为不够一组。

 # 解答

这道题的难点在于，是从链表的尾部开始组起的，而不是从链表的头部，如果是头部的话，那我们还是比较容易做的，因为你可以遍历链表，每遍历 k 个就拆分为一组来逆序。但是从尾部的话就不一样了，因为是单链表，不能往后遍历组起。不过这道题肯定是用递归比较好做

 先做一道类似的反转题

 在做这道题之前，我们不仿先来看看如果从头部开始组起的话，应该怎么做呢？例如：链表:1->2->3->4->5->6->7->8->null, K = 3。调整后：3->2->1->6->5->4->7->8->null。其中 7，8不调整，因为不够一组。

这道题我们可以用递归来实现，假设方法reverseKNode()的功能是将单链表的每K个节点之间逆序(从头部开始组起的哦);reverse()方法的功能是将一个单链表逆序。那么对于下面的这个单链表，其中 K = 3。

 我们把前K个节点与后面的节点分割出来：

 temp指向的剩余的链表，可以说是原问题的一个子问题。我们可以调用reverseKNode()方法将temp指向的链表每K个节点之间进行逆序。再调用reverse()方法把head指向的那3个节点进行逆序

 代码如下：

class Node{
      private String val;
      private Node next;
}

public Node reversePart(Node head  , int k){
    Node temp = head;
    for(int index = 1;index < k&&temp!=null;index++){
        temp = temp.next;
    }
    if(temp == null){
        return  head;
    }
    Node rNode = temp.next;
    temp.next = null;
    Node reverseNode = reverse(head);
    Node partNode = reversePart(rNode , k);
    head.next = partNode;
    return reverseNode;
}

public Node reverse(Node head ){
    if(head == null || head.next == null){
       return  head;
    }
    Node p = head;
    Node q = head.next;
    while (q!=null){
        Node tempNode = q.next;
        q.next = p;
        p=q;
        q=tempNode;
    }
    head.next=null;
    return p;
}

public Node main(Node head  , int k){
    Node tempNode1 = reverse(head);
    Node tempNode2 = reversePart(tempNode1 , k);
    return reverse(tempNode2);
}