LeetCode 725 Split Linked List in Parts

LeetCode 725

Split Linked List in Parts

• Problem Description：
  将链表分成若干子链表，相邻部分相差结点数不超过1，且排在链表靠前位置的子链表的结点数不小于排在链表靠后位置的子链表的结点数。

  具体的题目信息：
  https://leetcode.com/problems/split-linked-list-in-parts/description/

• Solution:

  • 解题思路：
    遍历链表获取链表长度length，已知最终得到的子链表的个数为k，设每个子链表至少长times=length/k，剩下mod = length%k个结点平均分给靠前的子链表，即前mod个子链表长度为times+1，后面的子链表长度为times。

  • 编程实现：
    （1）调用getlength()函数得到链表的总长度length
    （2）分两种情况讨论：

    • 当子链表可能出现空的情况：每个子链表长度最多为1
    • 当子链表不出现空的情况：设置count值记录前mod个子链表长度为times+1，后面的子链表长度为times

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<ListNode*> splitListToParts(ListNode* root, int k) {
        vector<ListNode*> result;
        ListNode*  p = root, *temp, *q;
        //获取链表长度
        int length = getlength(root);
        //times为每一子链表的基础长度（即每个子链表长度>=times）
        int times = length/k;
        //前mod个子链表的长度 = 基础长度+1
        int mod = length%k;
        //若times等于0说明子链表中靠后的子链表会出现空的情况
        if (times == 0) {
            while(p) {
                temp = new ListNode(p->val);
                temp->next = NULL;
                result.push_back(temp);
                p = p->next;
                k--;
            }
            while(k--) {
                temp = NULL;
                result.push_back(temp);
            }
        } else {
            //当每个子链表都不为空，通过count记录前mod个长度较长的子链表
            int count = 0;
            while(k--) {
                if (count<mod) {
                    temp = new ListNode(p->val);
                    root = temp;
                    temp->next = NULL;
                    p = p->next;
                    for (int i = 0; i < times; i++) {
                        q = new ListNode(p->val);
                        q->next = temp->next;
                        temp->next = q;
                        temp = q;
                        p = p->next;
                    }
                    result.push_back(root);
                    count++;
                } else {
                    //与前mod个子链表的区别仅仅是长度-1
                    temp = new ListNode(p->val);
                    root = temp;    
                    temp->next = NULL;
                    p = p->next;
                    for (int i = 1; i < times; i++) {
                        q = new ListNode(p->val);
                        q->next = temp->next;
                        temp->next = q;
                        temp = q;
                        p = p->next;
                    }
                    result.push_back(root);
                }
            }
        }
        return result;
    }
    //获取链表长度
    int getlength(ListNode* temp) {
        int len = 0;
        ListNode* p = temp;
        while(p) {
            len++;
            p = p->next;
        }
        return len;
    }
};