Insertion Sort List

https://leetcode.com/problems/insertion-sort-list/

Sort a linked list using insertion sort.

解题思路：

先回忆一下插入排序。对于num[i]，将他插入到前面已经排好序的0...i-1的合适的位置。i从0-n遍历。

这题对于链表操作的难度在于取得当前节点和插入处的前趋节点，因为链表只有next。所以只能取travserse和insert的前一个节点往后遍历。这里还用了一个dummy，接在head前面，因为head可能随时发生变化。最终只要返回dumm.next即可。

这里最容易错的地方就是最后注释，如果traverseNode.next已经被搬到前面去了，其实traverseNode就不要再往后了，因为此时traverseNode.next已经是之前的下一个节点了。

/**

 * Definition for singly-linked list.

 * public class ListNode {

 *     int val;

 *     ListNode next;

 *     ListNode(int x) {

 *         val = x;

 *         next = null;

 *     }

 * }

 */

public class Solution {

    public ListNode insertionSortList(ListNode head) {

        if(head == null || head.next == null){

            return head;

        }

        

        ListNode dummy = new ListNode(0);

        dummy.next = head;

        //traverseNode.next是真正的当前遍历节点，插入在insertNode后面

        ListNode traverseNode = head;

        

        while(traverseNode != null && traverseNode.next != null){

            ListNode insertNode = dummy;

            boolean isSwap = false;

            while(insertNode != traverseNode.next){

                if(insertNode.next.val > traverseNode.next.val){

                    isSwap = true;

                    ListNode tempNode = traverseNode.next;

                    traverseNode.next = tempNode.next;

                    tempNode.next = insertNode.next;

                    insertNode.next = tempNode;

                    break;

                }

                insertNode = insertNode.next;

            }

            //如果traverseNode.next插入到前面去了，traverseNode就不用往后了

            //比如3-2-1，2到前面去了，原来3.next=2，现在3.next=1，其实已经相当于往后一个了

            if(!isSwap){

                traverseNode = traverseNode.next;

            }

        }

        return dummy.next;

    }

}

后来在网上看到另一种方法，http://blog.csdn.net/linhuanmars/article/details/21144553，代码反而更简单。

上面我的方法是类似于一个in-place的方法，它不另外构造一个list的结构，而是在原来的list里调换各个node的顺序。下面的方法是，索性从dummy开始，重新组成一个list，所以这里dummy没有接在head后面。但实际上，由于链表的特点，即使不是in-place的，也不需要占新的内存。

代码比上面我的方法清晰很多。

/**

 * Definition for singly-linked list.

 * public class ListNode {

 *     int val;

 *     ListNode next;

 *     ListNode(int x) {

 *         val = x;

 *         next = null;

 *     }

 * }

 */

public class Solution {

    public ListNode insertionSortList(ListNode head) {

        if(head == null || head.next == null){

            return head;

        }

        

        ListNode dummy = new ListNode(0);

        // dummy.next = head;

        

        ListNode cur = head;

        while(cur != null){

            ListNode pre = dummy;

            while(pre.next != null && pre.next.val <= cur.val){

                pre = pre.next;

            }

            ListNode next = cur.next;

            cur.next = pre.next;

            pre.next = cur;

            cur = next;

        }

        return dummy.next;

    }

}