【Java】【LeetCode】147. Insertion Sort List

题目：

Sort a linked list using insertion sort.

A graphical example of insertion sort. The partial sorted list (black) initially contains only the first element in the list.
With each iteration one element (red) is removed from the input data and inserted in-place into the sorted list
 

Algorithm of Insertion Sort:

1. Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list.
2. At each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there.
3. It repeats until no input elements remain.

Example 1:

Input: 4->2->1->3
Output: 1->2->3->4

Example 2:

Input: -1->5->3->4->0
Output: -1->0->3->4->5

题解：

 Insertion Sort就是把一个一个元素往已排好序的list中插入的过程。

 初始时，sorted list是空，把一个元素插入sorted list中。然后，在每一次插入过程中，都是找到最合适位置进行插入。

 因为是链表的插入操作，需要维护pre，cur和next3个指针。

 pre始终指向sorted list的fakehead，cur指向当前需要被插入的元素，next指向下一个需要被插入的元素。

 

 当pre.next不为空以及pre.next所指向的元素比cur指向的元素值要大时，需要把cur元素插入到pre.next所指向元素之前。否则，pre指针后移。最后返回fakehead的next即可。

 

代码如下：

public class InsertionSortList
{

  public static void main(String[] args)
  {
    /**
     * Sort a linked list using insertion sort.
     * 
     * 
     * A graphical example of insertion sort. The partial sorted list (black)
     * initially contains only the first element in the list. With each iteration
     * one element (red) is removed from the input data and inserted in-place into
     * the sorted list
     * 
     * 
     * Algorithm of Insertion Sort:
     * 
     * Insertion sort iterates, consuming one input element each repetition, and
     * growing a sorted output list. At each iteration, insertion sort removes one
     * element from the input data, finds the location it belongs within the sorted
     * list, and inserts it there. It repeats until no input elements remain.
     * 
     * Example 1:
     * 
     * Input: 4->2->1->3 Output: 1->2->3->4 Example 2:
     * 
     * Input: -1->5->3->4->0 Output: -1->0->3->4->5
     */
    ListNode ln11 = new ListNode(4);
    ListNode ln12 = new ListNode(2);
    ListNode ln13 = new ListNode(1);
    ListNode ln14 = new ListNode(3);
    ln11.next = ln12;
    ln12.next = ln13;
    ln13.next = ln14;
    LeetCodeUtil.printNodeList(insertionSortList(ln11));
    ListNode ln21 = new ListNode(-1);
    ListNode ln22 = new ListNode(5);
    ListNode ln23 = new ListNode(3);
    ListNode ln24 = new ListNode(4);
    ListNode ln25 = new ListNode(0);
    ln21.next = ln22;
    ln22.next = ln23;
    ln23.next = ln24;
    ln24.next = ln25;
    LeetCodeUtil.printNodeList(insertionSortList(ln21));
  }

  public static ListNode insertionSortList(ListNode head)
  {
    if (head == null || head.next == null)
    {
      return head;
    }
    ListNode sortHead = new ListNode(0);
    while (head != null)
    {
      ListNode prev = sortHead;
      ListNode next = head.next;
      while (prev.next != null && head.val > prev.next.val)
      {
        prev = prev.next;
      }
      head.next = prev.next;
      prev.next = head;
      head = next;
    }
    return sortHead.next;
  }

}