LeetCode 分隔链表

问题描述
给定一个头结点为 root 的链表, 编写一个函数以将链表分隔为 k 个连续的部分。

每部分的长度应该尽可能的相等: 任意两部分的长度差距不能超过 1，也就是说可能有些部分为 null。

这k个部分应该按照在链表中出现的顺序进行输出，并且排在前面的部分的长度应该大于或等于后面的长度。

返回一个符合上述规则的链表的列表。

举例： 1->2->3->4, k = 5 // 5 结果 [ [1], [2], [3], [4], null ]

示例 1：

输入:

root = [1, 2, 3], k = 5

输出: [[1],[2],[3],[],[]]

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    vector<ListNode*> splitListToParts(ListNode* head, int k) {
        int len=0;
        ListNode *p=head;ListNode *t;
        //定义一个指针数组
        vector<ListNode*> arr(k,NULL);
        计算链表的长度
        while(p){
            len++;
            p=p->next;
        }
        p=head;
        int m,n,num=0;
        //m表示商，平均每个链表有几个结点
        //n表示余数，还剩几个结点
        m=len/k;
        n=len%k;
        for(int i=0;i<k&&p!=NULL;i++){
            arr[i]=p;
            int flag=i<n?1:0;
            //num表示这个链表的长度
            num=flag+m;
            //p指向链表的最后一个结点，t指向另一个链表的第一个结点，断开链表
            for(int j=1;j<num;j++){
                p=p->next;
            }
            t=p->next;
            p->next=NULL;
            p=t;
            
        }
        return arr;
    }
};