Insertion Sort List——链表的插入排序

Sort a linked list using insertion sort.

这道题跟 Sort List 类似，要求在链表上实现一种排序算法，这道题是指定实现插入排序。插入排序是一种O(n^2)复杂度的算法，基本想法相信大家都比较了 解，就是每次循环找到一个元素在当前排好的结果中相对应的位置，然后插进去，经过n次迭代之后就得到排好序的结果了。了解了思路之后就是链表的基本操作 了，搜索并进行相应的插入。时间复杂度是排序算法的O(n^2)，空间复杂度是O(1)。代码如下：

就是链表的插入排序，思路很简单的，就是一堆指针容易弄混淆，其实很简单的一道题。

/**
 * 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||head->next==NULL)
            return head;
        ListNode*fixflag=new ListNode(0);
        ListNode* start,*end,*pre,*flag;
        start=head;
        end=start->next;
        pre=start;
        fixflag->next=start;
        flag=fixflag;
        while(end!=NULL)
        {
        while(flag->next!=end)
        {
            if(end->val<=flag->next->val)
            {
                pre->next=end->next;
                end->next=flag->next;
                flag->next=end;
                end=pre->next;
                flag=fixflag;
                break;
            }
            flag=flag->next;
        }
        if(flag->next==end)
        {
            flag=fixflag;
            end=end->next;
            pre=pre->next;
            
        }
        
        }
        return fixflag->next;
        
    }
};

 网上看到一种更加简洁的代码：

public ListNode insertionSortList(ListNode head) {
  if(head == null)
    return null;
  ListNode helper = new ListNode(0);
  ListNode pre = helper;
  ListNode cur = head;
  while(cur!=null)
  {
    ListNode next = cur.next;
    pre = helper;
    while(pre.next!=null && pre.next.val<cur.val)
    {
      pre = pre.next;
    }
    cur.next = pre.next;
    pre.next = cur;
    cur = next;
  }
  return helper.next;
}