链表问题---将单向链表按某值划分成左边小，中间相等，右边大的形式

【题目】

给定一个单向链表的头节点head，节点的值类型是整型，再给定一个整数pivot。实现一个调整链表的函数，将链表调整为左部分都是值小于pivot的节点，中间部分都是值等于pivot的节点，右部分都是值大于pivot的节点。除这个要求外，对调整后的节点顺序没有更多的要求。

【进阶题目】

在原问题的要求之上再增加如下两个要求：

1. 在左、中、右三个部分的内部也做顺序要求，要求每部分里的节点从左到右的顺序与原链表中节点的先后次序一致。
2. 如果链表长度为N，要求时间复杂度O(N)，空间复杂度O(1)。

【基本思路】

原问题。将所有的节点放置到一个数组中，对这个数组进行partition调整（快排调整过程），再将每个数组中每个节点串起来即可。

#python3.5
def listPartition(head, pivot):
    def partition(nodeArr, pivot):
        left = -1
        right = len(nodeArr)
        index = 0
        while index < right:
            if nodeArr[index].val < pivot:
                left += 1
                nodeArr[left], nodeArr[index] = nodeArr[index], nodeArr[left]
                index += 1
            elif nodeArr[index].val == pivot:
                index += 1
            else:
                right -= 1
                nodeArr[index], nodeArr[right] = nodeArr[right], nodeArr[index]
            

    if head == None or head.next == None:
        return head
    cur = head
    n = 0
    while cur != None:
        n += 1
        cur = cur.next
    nodeArr = []
    cur = head
    while cur != None:
        nodeArr.append(cur)
        cur = cur.next
    partition(nodeArr, pivot)
    for i in range(n-1):
        nodeArr[i].next = nodeArr[i+1]
    nodeArr[-1].next = None
    return nodeArr[0]

进阶题目。按照原链表各个节点的对应顺序将链表分解成三部分，小于pivot的、等于pivot的，大于pivot的，之后再将三个连起来即可。

def listPartition2(head, pivot):
    if head == None or head.next == None:
        return head
    sH = None    #small部分的头
    sT = None    #small部分的尾
    eH = None    #equal部分的头
    eT = None    #equal部分的尾
    bH = None    #big部分的头
    bT = None    #big部分的尾
    while head != None:
        next = head.next
        head.next = None
        if head.val < pivot:
            if sH == None:
                sH = head
                sT = head
            else:
                sT.next = head
                sT = head
        elif head.val == pivot:
            if eH == None:
                eH = head
                eT = head
            else:
                eT.next = head
                eT = head
        else:
            if bH == None:
                bH = head
                bT = head
            else:
                bT.next = head
                bT = head
        head = next
    head = None
    if sT != None:
        head = sH
        if eH != None:
            sT.next = eH
        elif bH != None:
            sT.next = bH
    if eT != None:
        head = head if head != None else eH
        if bH != None:
            eT.next = bH
    return head if head != None else bH