Split the linked list [take next first and then cut the linked list to prevent chain breakage]

Preface

One of the core problems of linked list operation , It's a broken chain , The continuous chain needs to point to the following passive nodes with pointer variables first .

One 、 Split the list

Two 、 First next Then cut off the linked list

package everyday.listNode;

//  Split the list 
public class SplitListToParts {
    
    /* target： Given the list and how many shares , Split the list .  As long as you can determine how many nodes each linked list is divided into , Traversing the linked list , You can do the segmentation .  How to determine how many nodes each linked list is divided into ？ Chain length len  Take the remainder of the number of copies  &  Quotient of copies .  Remainder , In order to get the first few nodes, you can divide them into one more node ; Take business , In order to determine the number of basic nodes assigned to a linked list . */
    public ListNode[] splitListToParts(ListNode head, int k) {
    
        //  return k A linked list .
        ListNode[] ans = new ListNode[k];
        //  Traversing the linked list , Find the length of the linked list .
        int len = 0;
        ListNode p = head;
        while (p != null && (p = p.next) == p) ++len;
        //  Remainder , In order to get the first few nodes, you can divide them into one more node .
        int mod = len % k;
        //  Take business , In order to determine the number of basic nodes assigned to a linked list .
        int val = len / k;
        //  Start split , And the assignment .
        int idx = 0;
        p = head;
        while (idx < k) {
    
            //  If there is no divisible situation , Then each of the following can only be divided into null.
            if (p == null) {
    
                ans[idx++] = null;
                continue;
            }
            //  Can be divided into non null node , Assign the initial node to the array .
            ans[idx++] = p;
            //  Divide the linked list according to the current number of nodes that can be divided .
            for (int i = 1;i < (mod != 0 ? 1 : 0) + val;i++) p = p.next;
            //  Get the next node , And cut off the linked list .
            ListNode next = p.next;
            p.next = null;
            //  Set the initial node of the new linked list , Start the next round of assignment .
            p = next;
            // mod It indicates how many linked lists can be assigned to an additional node , Until the score is finished .
            if (mod > 0) --mod;
        }
        //  Return the filled linked list array .
        return ans;
    }

    // Definition for singly-linked list.
    public class ListNode {
    
        int val;
        ListNode next;

        ListNode() {
    
        }

        ListNode(int val) {
    
            this.val = val;
        }

        ListNode(int val, ListNode next) {
    
            this.val = val;
            this.next = next;
        }
    }
}

summary

1） If you don't want to break the chain, you need to point to the following passive nodes with pointer variables .

reference

[1] LeetCode Split the list