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;
}
};