inertion-sort-list

Author: DmrfCoder

LeetCode/Doc/使用插入排序对链表进行排序.md

@@ -0,0 +1,30 @@
+# insertion-sort-list(使用插入排序对链表进行排序)
+
+<center>知识点：</center>
+
+
+## 题目描述
+
+Sort a linked list using insertion sort.
+
+## 解题思路
+
+首先明确什么是数组的插入排序：
+首先将第二个数与第一个数进行对比，如果第二个数比第一个数小，则将第二个数插入到第一个数之前，这样保证前两个数是有序的；
+接下来将第三个数与前两个数对比，发现有比第三个数大的数即将第三个数插入到对应数的前面，这样一次插入可保证前三个数是有序的；
+以此类推，将后面的i个数分别其前面的i-1个数进行对比，并将其插入到第一个比其大的数前面，最后即可完成排序。
+
+链表与数组相比唯一的不同在于链表不能通过下标访问元素，而且链表不能像数组那样通过下标减1的方式访问到上一个元素，针对这种情况我们将上面的算法做出如下改进：
+
+​     使用curNode、nextNode两个指针，curNode初始指向head，nextNode初始指向curNode.next，curNode的意思是从head节点开始到curNode节点之间的所有元素均为有序的，这在初始时时成立的（初始时curNode=head，所以当然成立），nextNode指向的是curNode的下一个元素，我们使用这个nextNode指针的目的是判断已经确定的有序链表[head,curNode]之外的下一个节点与当前有序链表的关系，具体的：
+
+- 如果nextNode.val>=curNode.val，那么说明[head,curNode]+nextNode构成的链表也是有序的，所以应该讲curNode向后移，即curNode=curNode.next，同时nextNode=curNode.next.
+- 如果nextNode.val<curNode.val，这个时候我们就需要将nextNode这个节点插入到之前有序链表的某一个位置，以保证[head,curNode]+headNode构成的链表是有序的，那么插在那个位置呢？就需要从head节点开始往后找了，方法是找到第一个比nextNode.val大的节点记为P，然后将nextNode插入到P之前即可，需要注意的是链表插入的时候需要借助一个辅助指针记住插入位置的前一个节点以方便插入。
+- 如果nextNode==null，说明整个链表排序完成，返回即可。
+
+
+
+
+## 代码
+
+[这里](../src/five/Solution.java)

LeetCode/out/production/LeetCode/five/ListNode.class

@@ -0,0 +1,70 @@
+package five;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+
+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 tempHead = new ListNode(0);
+        tempHead.next = head;
+
+
+        ListNode curNode = head;
+        ListNode indexNode;
+
+        while (curNode != null) {
+
+            indexNode = curNode.next;
+            while (indexNode != null && indexNode.val >= curNode.val) {
+                indexNode = indexNode.next;
+                curNode = curNode.next;
+            }
+
+            if (indexNode == null) {
+                return tempHead.next;
+            }
+
+            ListNode copyOfTempHead = tempHead;
+            ListNode copyOfHead = tempHead.next;
+
+            while (copyOfHead.val < indexNode.val) {
+                copyOfTempHead = copyOfTempHead.next;
+                copyOfHead = copyOfHead.next;
+            }
+            copyOfTempHead.next = indexNode;
+            curNode.next = indexNode.next;
+            indexNode.next = copyOfHead;
+
+
+        }
+
+        return tempHead.next;
+    }
+
+    public static void main(String[] args) {
+        ListNode head = new ListNode(3);
+        ListNode node2 = new ListNode(2);
+        ListNode node1 = new ListNode(1);
+        head.next = node2;
+        node2.next = node1;
+
+        Solution solution = new Solution();
+        solution.insertionSortList(head);
+    }
+}

LeetCode/out/production/LeetCode/five/Solution.class

@@ -146,4 +146,5 @@
 - [evaluate-reverse-polish-notation(计算逆波兰式的值)](./LeetCode/Doc/计算逆波兰式的值.md)
 - [max-points-on-a-line(同一条直线上的最多的点的数量)](./LeetCode/Doc/同一条直线上的最多的点的数量.md)
 - [sort-list(排序List)](./LeetCode/Doc/排序List.md)
+- [insertion-sort-list(使用插入排序对链表进行排序)](./LeetCode/Doc/使用插入排序对链表进行排序.md)