在单链表上实现插入排序

问题

给单链表排序（升序排列，要保持稳定性），要求通过改变结点的next指针从而改变结点的位置，而不是只交换结点的值来使得其有序！时间复杂度为O(N^2)，空间复杂度为O(1)。已知链表结点的实现如下：

struct ListNode
{
    int value;
    ListNode* next;
    ListNode(int v)
    : value(v), next(NULL) {}
};

思路

这里很明显就是要我们做插入排序了，当然，冒泡也不是不可以，只是冒泡写起来麻烦，且性能是最差的。

插入排序怎么写呢？
这个算法的思想是这样的：
1. 维护两部分，一是已排序的部分，一是待排序的部分；
2. 一开始已排序部分为NULL；
3. 每次取出待排序部分的第一个元素A，和已排序的部分逐个比较（从头往后或从后往前都可以，不过单链表只能够从头往后比较），找到第一个大于A的元素B；
4. 将A插在B的前面一个位置（这时需要注意了，如果B原来是链表头，那么A将变成新的链表头，此时要记得更新链表头指针）。

代码

#include <iostream>
#include <string>
using namespace std;


struct ListNode
{
    int value;
    ListNode* next;
    ListNode(int v)
    : value(v), next(NULL) {}
};


ListNode* sortList(ListNode* head) {
    // 注意这样写，是不需要额外判断head是否为NULL的
    ListNode *newHead = NULL, *toInsert = head;
    while (toInsert != NULL) {
        ListNode *current = newHead, *last = NULL, *next = toInsert->next;
        // 从头往后找到第一个大于toInsert->value的元素
        while (current != NULL && current->value <= toInsert->value) {
            last = current;
            current = current->next;
        }

        if (last == NULL) {
            // 如果比任何已排序的数字都要小，那么就成为新的头部
            toInsert->next = newHead;
            newHead = toInsert;
        } else {
            // 否则插入到last的后面
            toInsert->next = last->next;
            last->next = toInsert;
        }

        toInsert = next;
    }
    return newHead;
}

// 打印链表
void display(ListNode* head) {
    while (head != NULL) {
        cout << head->value << ' ';
        head = head->next;
    }
    cout << endl;
}


int main() {
    ListNode* head = new ListNode(5);
    head->next = new ListNode(4);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(2);
    head->next->next->next->next = new ListNode(1);
    display(head);

    ListNode* head2 = sortList(head);
    display(head2);

    return 0; 
}