LeetCode Insertion Sort List

class Solution {
public:
    ListNode *insertionSortList(ListNode *head) {
        if (head == NULL) return NULL;
        ListNode* sorted_head = head;
        ListNode* unsorted_head = head->next;
        head->next = NULL;
        
        ListNode* cur = unsorted_head;

        while (cur != NULL) {
            unsorted_head = cur->next;
            cur->next = NULL;
            sorted_head = insertNode(sorted_head, cur);
            cur = unsorted_head;
        }
        
        return sorted_head;
    }
    
    ListNode* insertNode(ListNode* list, ListNode* node) {
        if (list == NULL && node == NULL) return NULL;
        if (node == NULL) return list;
        if (list == NULL) return node;
        ListNode* cur = list;
        ListNode* pre = NULL;
        while (cur != NULL && cur->val < node->val) {
            pre = cur;
            cur = cur->next;
        }
        if (pre == NULL) {
            node->next = list;
            return node;
        } else {
            node->next = pre->next;
            pre->next = node;
            return list;
        }
    }
};

感觉很简单，写起来又是这错那错

第二轮顺一些，先在纸上写好

Sort a linked list using insertion sort.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *insertionSortList(ListNode *head) {
        if (head == NULL) {
            return NULL;
        }
        ListNode* sorted = head;
        
        ListNode* cur = head->next;
        // must after last line
        head->next = NULL;
        
        while (cur != NULL) {
            ListNode* next = cur->next;
            cur->next = NULL;
            sorted = insertNode(sorted, cur);
            cur = next;
        }
        ListNode* pre = NULL;
        return sorted;
    }
    
    ListNode *insertNode(ListNode* head, ListNode* node) {
        if (head == NULL) {
            return node;
        }
        if (node == NULL) {
            return head;
        }
        ListNode* cur = head;
        ListNode* pre = NULL;
        while (cur != NULL && cur->val < node->val) {
            pre = cur;
            cur = cur->next;
        }
        node->next = cur;
        if (pre == NULL) {
            return node;
        } else {
            pre->next = node;
            return head;
        }
    }
};

 再来一发Python版本的，没有用python专用语法，比cpp慢了30倍

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

class Solution:
    # @param head, a ListNode
    # @return a ListNode
    def insertionSortList(self, head):
        if head is None:
            return None
        
        cur = head.next
        sorted = head
        sorted.next = None
        
        while cur is not None:
            next = cur.next
            cur.next = None
            sorted = self.insertNode(sorted, cur)
            cur = next
        return sorted
        
    def insertNode(self, head, node):
        if head is None:
            return node
        
        if node is None:
            return head
        
        cur = head
        pre = None
        
        while (cur is not None and cur.val < node.val):
            pre = cur
            cur = cur.next
        
        node.next = cur
        if pre is None:
            return node
        else:
            pre.next = node
            return head

 再来：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        ListNode* list2 = NULL;
        
        ListNode* curr = head;
        
        while (curr != NULL) {
            ListNode* next = curr->next;
            list2 = insertion(list2, curr);   
            curr = next;
        }
        return list2;
    }
    
    ListNode* insertion(ListNode* list, ListNode* node) {
        ListNode* head = list;
        ListNode* prev = NULL;
        while (list != NULL && node->val > list->val) {
            prev = list;
            list = list->next;
        }
        if (prev == NULL) {
            node->next = list;
            head = node;
        } else {
            node->next = prev->next;
            prev->next = node;
        }
        return head;
    }
};