leetcode刷题系列----模式2(Datastructure 链表)- 725(M):Split Linked List in Parts 分割链表

leetcode刷题系列----模式2(Datastructure 链表)- 725(M):Split Linked List in Parts 分割链表

Tips

• 更多题解请见本系列目录
• 本题套熟练掌握链表的定义，牢记尾结点必定要指向为空。在敲代码时，大脑思考指针的前进方向。
• 此处均匀分布节点个数，有个模运算，余数应当小于划分数，然后前面小于等于余数的每个划分额外多分得一个节点。part_szie = q +（1 if i<r else 0）

Python

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def splitListToParts(self, head: ListNode, k: int) -> List[ListNode]:
        temp = head
        count = 0
        while temp:
            count += 1
            temp = temp.next
        
        q, r = count//k, count%k
        parts = [None for _ in range(k)]
        i, current = 0, head
        while i<k and current:
            parts[i] = current
            part_size = q+(1 if i<r else 0)
            for item in range(part_size-1): current = current.next
            next_part = current.next
            current.next = None
            current = next_part
            i += 1
        return parts

C++

/**
 * 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) {
        ListNode* temp = head;
        int count = 0;
        while(temp!=nullptr){count+=1; temp=temp->next;}
        int q = count/k;
        int r = count%k;
        vector<ListNode*> parts(k, nullptr);
        ListNode* current = head;
        for(int i=0; i<k && current!=nullptr; i++)
        {
            parts[i] = current;
            int part_size = q + (i<r ? 1 : 0);
            for(int j=1; j<part_size; j++) current=current->next;
            ListNode* next_part = current->next;
            current->next = nullptr;
            current = next_part;
        }
        return parts;
    }
};

C#

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int val=0, ListNode next=null) {
 *         this.val = val;
 *         this.next = next;
 *     }
 * }
 */
public class Solution {
    public ListNode[] SplitListToParts(ListNode head, int k) {
        ListNode temp = head;
        int count = 0;
        while(temp!=null){count+=1; temp=temp.next;}
        int q = count/k;
        int r = count%k;
        ListNode[] parts = new ListNode[k];
        ListNode current = head;
        for(int i=0; i<k && current!=null; i++)
        {
            parts[i] = current;
            int part_size = q + (i<r ? 1 : 0);
            for(int j=1; j<part_size; j++) current=current.next;
            ListNode next_part = current.next;
            current.next = null;
            current = next_part;
        }
        return parts;
    }
} 

Java

/**
 * 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; }
 * }
 */
class Solution {
    public ListNode[] splitListToParts(ListNode head, int k) {
        ListNode temp = head;
        int count = 0;
        while(temp!=null){count+=1; temp=temp.next;}
        int q = count/k;
        int r = count%k;
        ListNode[] parts = new ListNode[k];
        ListNode current = head;
        for(int i=0; i<k && current!=null; i++)
        {
            parts[i] = current;
            int part_size = q + (i<r ? 1 : 0);
            for(int j=1; j<part_size; j++) current=current.next;
            ListNode next_part = current.next;
            current.next = null;
            current = next_part;
        }
        return parts;
    }
}