725. 分隔链表--PYTHON

自己1：暴力破解法

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def splitListToParts(self, root, k):
        """
        :type root: ListNode
        :type k: int
        :rtype: List[ListNode]
        """
        List_size = 0  #确定链表长度

        p = root
        while p:
            List_size += 1
            p = p.next

        res_list = list()
        if List_size <= k: #当分段数大于等于元素数
            p = root
            for i in range(k):
                if p:
                    tmp = ListNode(p.val)
                    res_list.append(tmp)
                    p = p.next
                else:
                    res_list.append(None)
        else:  #当分段数小于元素数
            # node_per = List_size/k
            # node_plus = List_size%k
            node_per,node_plus = divmod(List_size,k)
            per_list = list()   #设置每份的元素数
            for i in range(k):
                if i < node_plus:
                    per_list.append(int(node_per+1))
                else:
                    per_list.append(node_per)

            p = root#重置指针到表头
            for per_num in per_list:
                head_ = ListNode(-1)
                tail = head_
                for i in range(per_num):
                    tmp = ListNode(p.val)
                    tail.next = tmp
                    tail = tail.next
                    p = p.next
                res_list.append(head_.next)

        return res_list 

大佬1：新建链表法，期间有两个小tricky，可以关注一下注释，笔者也是才get到。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def splitListToParts(self, root, k):
        """
        :type root: ListNode
        :type k: int
        :rtype: List[ListNode]
        """
        cur = root
        for N in xrange(1001):  #统计链表内的元素数，get到了。
            if not cur: break
            cur = cur.next
        width, remainder = divmod(N, k)

        ans = []
        cur = root
        for i in xrange(k):
            head = write = ListNode(None)
            for j in xrange(width + (i < remainder)):#加True等价于加1，get到了
                write.next = write = ListNode(cur.val)
                if cur: cur = cur.next  #同暴力破解法，一样为创建新节点然后对返回链表进行填充
            ans.append(head.next)
        return ans

大佬2：上面方式相同，不过不会创建新的链表节点，而是从原始链表上将原始连接进行拆分。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def splitListToParts(self, root, k):
        """
        :type root: ListNode
        :type k: int
        :rtype: List[ListNode]
        """
        cur = root
        for N in xrange(1001):
            if not cur: break
            cur = cur.next
        width, remainder = divmod(N, k)

        ans = []
        cur = root
        for i in xrange(k):
            head = cur
            for j in xrange(width + (i < remainder) - 1):
                if cur: cur = cur.next
            if cur:
                cur.next, cur = None, cur.next
            ans.append(head)
        return ans