对List排序

Author: DmrfCoder

LeetCode/Doc/同一条直线上的最多的点的数量.md

@@ -55,6 +55,69 @@ return maxCount
 
 完整逻辑请看详细代码。
 
+```java
+public int maxPoints(Point[] points) {
+
+        int length = points.length;
+        int maxPointCount = 0;
+        for (int startIndex = 0; startIndex < length; startIndex++) {
+            Map<String, Integer> maxPointMap = new HashMap<>();
+            int commonPointCount = 0;
+            int tempMaxCount = 1;
+            for (int endIndex = startIndex + 1; endIndex < length; endIndex++) {
+                int distanceX = points[startIndex].x - points[endIndex].x;
+                int distanceY = points[startIndex].y - points[endIndex].y;
+
+
+                if (distanceX == 0 && distanceY == 0) {
+                    commonPointCount += 1;
+                } else {
+                    String curStrDis;
+                    if (distanceX == 0) {
+                        curStrDis = "distanceX";
+                    } else if (distanceY == 0) {
+                        curStrDis = "distanceY";
+                    } else {
+                        int maxCommonDivisor = commonDivisor(distanceX, distanceY);
+                        if (maxCommonDivisor != 0) {
+                            distanceX = distanceX / maxCommonDivisor;
+                            distanceY = distanceY / maxCommonDivisor;
+                        }
+
+                        int flag = 0;
+
+                        if (distanceX < 0) {
+                            distanceX = -distanceX;
+                            flag++;
+                        }
+                        if (distanceY < 0) {
+                            distanceY = -distanceY;
+                            flag++;
+                        }
+
+                        curStrDis = String.valueOf(distanceX) + distanceY;
+                        if (flag == 1) {
+                            curStrDis = "-" + curStrDis;
+                        }
+                    }
+
+                    if (maxPointMap.containsKey(curStrDis)) {
+                        tempMaxCount = Math.max(tempMaxCount, maxPointMap.get(curStrDis) + 1);
+                        maxPointMap.put(curStrDis, maxPointMap.get(curStrDis) + 1);
+                    } else {
+                        //初始时put进去2，一个点是起始点，另一个点是当前点
+                        maxPointMap.put(curStrDis, 2);
+                        tempMaxCount = Math.max(tempMaxCount, 2);
+                    }
+                }
+            }
+            maxPointCount = Math.max(maxPointCount, tempMaxCount + commonPointCount);
+        }
+
+        return maxPointCount;
+    }
+```
+
 ## 代码
 
 [这里](../src/three/Solution.java)

LeetCode/Doc/排序List.md

@@ -0,0 +1,59 @@
+# sort-list(排序List)
+
+<center>知识点：排序，链表</center>
+
+
+## 题目描述
+
+Sort a linked list in O(n log n) time using constant space complexity.
+
+使用常量空间在O（n log n）时间复杂度内对链表进行排序。
+
+## 解题思路
+
+首先思考常见排序算法的事件复杂度及空间复杂度（参考：[八大常见排序算法介绍](https://ai-exception.blog.csdn.net/article/details/79053814)）：
+
+| 排序方法     | 时间复杂度                            | 空间复杂度       |
+| ------------ | ------------------------------------- | ---------------- |
+| 直接插入排序 | $T(n)=O(n^2)$                         | $S(n)=O(1)$      |
+| 希尔排序     | $T(n)=O(n^{1.5})$                     | $S(n)=O(1)$      |
+| 冒泡排序     | $T(n)=O(n^2)$                         | $S(n)=O(1)$      |
+| 快速排序     | $T(n)=O(nlog_2n)$                     | $S(n)=O(log_2n)$ |
+| 选择排序     | $S(n)=O(1)$                           | $T(n)=O(n^2)$    |
+| 堆排序       | $T(n)=O(nlog_2n)$                     | $S(n)=O(1)$      |
+| 归并排序     | $T(n)=O(nlog_2n)$                     | $S(n)=O(n)$      |
+| 基数排序     | $T(n)=O(d*n)$ d为排序数中最大数的位数 | $S(n)=O(n)$      |
+
+从上表中可以看出，对数组而言，时间复杂度为$O（nlogn）$的排序算法有：快速排序、堆排序、归并排序。
+
+快速排序和堆排序都对数组中下标的使用较为依赖，相比之下，归并排序更适合链表，再考虑到数组中归并排序的空间复杂度之所以为$O(n)$是因为合并的时候需要用一个辅助数组记录合并后的值以保证原数组中的数字排序不被破坏，而链表可以使用指针保证这一点而不需要额外辅助数组，所以空间复杂度会降为$O(1)$.
+
+综上，使用归并排序可以很好地解决本问题。
+
+大致逻辑：
+
+```
+fun listSort(head):
+		centerNode=head链表的中间节点
+		//分而治之的思想，分别排序后一半链表和前一半链表
+		left=listSort(centerNode.next)
+		//将centerNode的next置位null，保证同样是head为头结点，现在的链表长度为原来的一半
+		right=centerNode.next=null
+		listSort(head)
+		//合并两个子链表
+		return merge(left,right)
+```
+
+这里涉及到找链表中间节点的问题，方法是使用两个指针p、q，初始时p指向head，q指向head.next，当q不为null时：
+
+```
+p=p.next
+q=q.next.next
+```
+
+利用两个指针行走速度快慢的不同最终实现找出链表的中间节点，注意处理好空指针异常即可，这个算法称为快慢指针算法。
+
+
+## 代码
+
+[这里](../src/four/Solution.java)

LeetCode/out/production/LeetCode/four/ListNode.class

@@ -0,0 +1,90 @@
+package four;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+
+/**
+ * Definition for singly-linked list.
+ */
+
+class ListNode {
+    int val;
+    ListNode next;
+
+    ListNode(int x) {
+        val = x;
+        next = null;
+    }
+}
+
+public class Solution {
+    public ListNode sortList(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+        ListNode startNode, endNode;
+        startNode = head;
+        endNode = head.next;
+
+        while (startNode != null && endNode != null && endNode.next != null) {
+            startNode = startNode.next;
+            endNode = endNode.next.next;
+        }
+
+
+        ListNode right = sortList(startNode.next);
+        startNode.next = null;
+        ListNode left = sortList(head);
+
+
+        return mergeList(left, right);
+    }
+
+    private ListNode mergeList(ListNode left, ListNode right) {
+        ListNode tempListNode = new ListNode(0);
+        ListNode p = tempListNode;
+
+        while (left != null && right != null) {
+            if (left.val < right.val) {
+                p.next = left;
+                p = p.next;
+                left = left.next;
+            } else {
+                p.next = right;
+                p = p.next;
+                right = right.next;
+            }
+        }
+        if (left != null) {
+            p.next = left;
+        }
+        if (right != null) {
+            p.next = right;
+        }
+
+
+        return tempListNode.next;
+    }
+
+    public static void main(String[] args) {
+        ListNode head = new ListNode(1);
+        ListNode node2 = new ListNode(2);
+        ListNode node3 = new ListNode(3);
+        ListNode node4 = new ListNode(4);
+        ListNode node5 = new ListNode(5);
+        ListNode node6 = new ListNode(6);
+        ListNode node7 = new ListNode(7);
+
+        head.next = node7;
+        node7.next = node3;
+        node3.next = node2;
+        node2.next = node4;
+        node4.next = node5;
+
+        Solution solution = new Solution();
+        head = solution.sortList(head);
+        int a = 0;
+    }
+}

LeetCode/out/production/LeetCode/four/Solution.class

@@ -145,4 +145,5 @@
 - [minimum-depth-of-binary-tree(求解二叉树的最小深度)](./LeetCode/Doc/二叉树的最小深度.md)
 - [evaluate-reverse-polish-notation(计算逆波兰式的值)](./LeetCode/Doc/计算逆波兰式的值.md)
 - [max-points-on-a-line(同一条直线上的最多的点的数量)](./LeetCode/Doc/同一条直线上的最多的点的数量.md)
+- [sort-list(排序List)](./LeetCode/Doc/排序List.md.md)