链表排序相关

将链表按给定标准值（pivot）分割

Partition List https://leetcode.com/problems/partition-list/
Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.
You should preserve the original relative order of the nodes in each of the two partitions.
For example,
Given 1->4->3->2->5->2 and x = 3,
return 1->2->2->4->3->5.
给定一个值，按值将链表分割成两半。且要求稳定。
想法：三个游标，两个游标分别为两部分链表的头，一个游标游走在原链表判断该将此节点归给哪个头后面。

public ListNode partition(ListNode head, int x) {
    ListNode first = new ListNode(0), sec = new ListNode(0);
    ListNode firIter = first, secIter = sec;
    for(ListNode iter = head; iter != null; iter = iter.next){
        if(iter.val < x){
            firIter.next = iter;
            firIter = iter;
        }else{
            secIter.next = iter;
            secIter = iter;
        }
    }
    secIter.next = null;
    firIter.next = sec.next;
    return first.next;
}

链表的排序（快排、插入）

快速排序：O（nlogN）
按照partition的思想，先将链表按头的值分成两半（递归做此操作），最后合并两半即可。会超时。
直接用交换值的思想交换即可

public ListNode sortList(ListNode head){
    sortRecurse(head, null);
    return head;
}
private void swap(ListNode fir, ListNode sec){
    if(fir == sec) return;
    else{
        fir.val ^= sec.val;
        sec.val ^= fir.val;
        fir.val ^= sec.val;
    }
}
public void sortRecurse(ListNode start, ListNode end){
    if(start == end || start.next == end) return;
    ListNode flag = start, boarder = flag, iter = flag.next;
    while(iter != end){
        if(iter.val < flag.val){
            boarder = boarder.next;
            swap(boarder, iter);
        }
        iter = iter.next;
    }
    swap(flag, boarder);
    sortRecurse(flag, boarder);
    sortRecurse(boarder.next, end);
}

插入排序：由于正常插排是从当前要插入的元素向前走，但是链表无法从后向前走，因此每次从前向后找

public ListNode insertionSortList(ListNode head) {
    ListNode newhead = new ListNode(Integer.Min);
    newhead.next = head;
    boolean ifconvert;
    for(ListNode prenode = newhead, node = head; node != null;){
        ListNode iter = newhead;
        ifconvert = false;
        for(; iter.next != node; iter = iter.next){
            if(iter.next.val > node.val){
                prenode.next = node.next;
                node.next = iter.next;
                iter.next = node;
                node = prenode;
                ifconvert = true;
                break;
            }
        }
        if(!ifconvert) prenode = prenode.next;
        node = node.next;
    }
}