LeetCode 725. Split Linked List in Parts (分裂链表)

Given a (singly) linked list with head node root, write a function to split the linked list into k consecutive linked list "parts".

The length of each part should be as equal as possible: no two parts should have a size differing by more than 1. This may lead to some parts being null.

The parts should be in order of occurrence in the input list, and parts occurring earlier should always have a size greater than or equal parts occurring later.

Return a List of ListNode‘s representing the linked list parts that are formed.

Examples 1->2->3->4, k = 5 // 5 equal parts [ [1], [2], [3], [4], null ]

Example 1:

Input:
root = [1, 2, 3], k = 5
Output: [[1],[2],[3],[],[]]
Explanation:
The input and each element of the output are ListNodes, not arrays.
For example, the input root has root.val = 1, root.next.val = 2, \root.next.next.val = 3, and root.next.next.next = null.
The first element output[0] has output[0].val = 1, output[0].next = null.
The last element output[4] is null, but it‘s string representation as a ListNode is [].

Example 2:

Input:
root = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3
Output: [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
Explanation:
The input has been split into consecutive parts with size difference at most 1, and earlier parts are a larger size than the later parts.

题目标签:Linked List

  题目给了我们一个链表,还给了我们k,让我们把链表分成 k 个部分,使得每一个部分尽可能相等。

  首先,我们要知道链表的长度 len,利用 len 和 k 来分组。

  举例:

    1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10

    len = 10; k = 7 的话;

    首先计算 base =  len / k = 10 / 7 = 1;

    然后计算 leftover = len % k = 10 % 7 = 3;

    先把每一个小组的base 值填入

    [1, 1, 1, 1, 1, 1, 1]  一共有7个小组,每个小组目前有1个node

    然后把 leftover 分别加 1到每一个小组,从前到后,直到加完。

    [2, 2, 2, 1, 1, 1, 1]

    这样的话,一共有7个小组,前三个小组,每一组有2个 nodes,后面4个小组,每一组有1个node。

    这里写成 array 方便理解,答案中只需要知道 base, 然后把 leftover 加上就可以。

    所以根据上面的 array, 就可以把原链表分组为:

    [1 -> 2]   [3 -> 4]   [5 -> 6]   [7]   [8]   [9]   [10]

Java Solution:

Runtime beats 59.09%

完成日期:12/07/2017

关键词:singly-linked list

关键点:计算出base 和 leftover

 1 /**
 2  * Definition for singly-linked list.
 3  * public class ListNode {
 4  *     int val;
 5  *     ListNode next;
 6  *     ListNode(int x) { val = x; }
 7  * }
 8  */
 9 class Solution
10 {
11     public ListNode[] splitListToParts(ListNode root, int k)
12     {
13         ListNode[] list = new ListNode[k];
14         int len = 0;
15         ListNode cursor = root;
16         int base = 0;
17         int leftover = 0;
18
19         // count the length
20         while(cursor != null)
21         {
22             cursor = cursor.next;
23             len++;
24         }
25
26         // calculate the base and leftover
27         base = len / k;
28         leftover = len % k;
29         cursor = root;
30
31         // iterate each group
32         for(int i=0; i<k; i++)
33         {
34             list[i] = cursor; // save this group head
35             ListNode tail = null;
36             int groupSize = base;
37
38             // set up correct group size
39             if(leftover > 0)
40             {
41                 groupSize++;
42                 leftover--;
43             }
44
45             // iterate this group nodes
46             for(int j=0; j<groupSize; j++)
47             {
48                 if(j == groupSize - 1) // approach to the end of this group
49                     tail = cursor;
50
51                 cursor = cursor.next;
52             }
53
54             if(groupSize > 0) // link this group tail to null
55                 tail.next = null;
56         }
57
58
59         return list;
60     }
61 }

参考资料:N/A

LeetCode 题目列表 - LeetCode Questions List

题目来源:https://leetcode.com/

时间: 2024-10-09 00:58:29

LeetCode 725. Split Linked List in Parts (分裂链表)的相关文章

#Leetcode# 725. Split Linked List in Parts

https://leetcode.com/problems/split-linked-list-in-parts/ Given a (singly) linked list with head node root, write a function to split the linked list into k consecutive linked list "parts". The length of each part should be as equal as possible:

725. Split Linked List in Parts 拆分链表

Given a (singly) linked list with head node root, write a function to split the linked list into k consecutive linked list "parts". The length of each part should be as equal as possible: no two parts should have a size differing by more than 1.

725. Split Linked List in Parts把链表分成长度不超过1的若干部分

[抄题]: Given a (singly) linked list with head node root, write a function to split the linked list into k consecutive linked list "parts". The length of each part should be as equal as possible: no two parts should have a size differing by more t

LC 725. Split Linked List in Parts

Given a (singly) linked list with head node root, write a function to split the linked list into k consecutive linked list "parts". The length of each part should be as equal as possible: no two parts should have a size differing by more than 1.

[LeetCode] Split Linked List in Parts 分割链表成部分

Given a (singly) linked list with head node root, write a function to split the linked list into k consecutive linked list "parts". The length of each part should be as equal as possible: no two parts should have a size differing by more than 1.

[Swift]LeetCode725. 分隔链表 | Split Linked List in Parts

Given a (singly) linked list with head node root, write a function to split the linked list into k consecutive linked list "parts". The length of each part should be as equal as possible: no two parts should have a size differing by more than 1.

LeetCode 234. Palindrome Linked List (回文链表)

Given a singly linked list, determine if it is a palindrome. Follow up:Could you do it in O(n) time and O(1) space? 题目标签:Linked List 题目给了我们一个 linked list,让我们判断它是不是回文. 这里可以利用 #206 Reverse Linked List 把右边一半的链表 倒转,然后从左右两头开始比较链表是否是回文. 这样的话,首先要找到链表的中间点,然后

LeetCode 234 Palindrome Linked List(回文链表)(*)(?)

翻译 给定一个单链表,确定它是否是回文的. 跟进: 你能够在O(n)时间和O(1)空间下完毕它吗? 原文 Given a singly linked list, determine if it is a palindrome. Follow up: Could you do it in O(n) time and O(1) space? 进阶 bool judge(ListNode *head, ListNode* &cur) { if (!head) return true; if (!jud

LeetCode OJ - Reverse Linked List II

题目: Reverse a linked list from position m to n. Do it in-place and in one-pass. For example:Given 1->2->3->4->5->NULL, m = 2 and n = 4, return 1->4->3->2->5->NULL. Note:Given m, n satisfy the following condition:1 ≤ m ≤ n ≤ l