add leetcode 147 insertionSort on singly-linkedlist

Author: UbuntuLover

linkedlist/Leetcode876MiddleOftheLinkedList.md

@@ -67,4 +67,8 @@ public ListNode middleNode(ListNode head) {
 ```
 复杂度分析：
 - 时间复杂度：_O(N)_
-- 空间复杂度：_O(1)_
+- 空间复杂度：_O(1)_
+
+
+
+冠状病毒

linkedlist/README.md

@@ -51,7 +51,7 @@ public class Linkedlist {
 Quack.h的内容：
 ```c
 #include<stdio.h>
-#include <stdlib.h>
+#include<stdlib.h>
 
 typedef struct _node* Quack;
 
@@ -76,7 +76,7 @@ Quack.c
 
 #define MARKERDATA INT_MAX // dummy data
 
-struct node {
+struct _node {
    int data;
    struct node *next;
 };
@@ -233,11 +233,14 @@ gcc Quack.c revarg.c
 >> 9876543210
 ```
 
-
 [LeetCode876 链表中间节点题解](linkedlist/Leetcode876MiddleOftheLinkedList.md)
 
 [Leetcode19 删除倒数n个节点题解](linkedlist/leetcode19.md)
 
 [Leetcode206 反转链表题解](linkedlist/leetcode206.md)
 
-[Leetcode61 旋转链表题解](linkedlist/leetcode61.md)
+[Leetcode61 旋转链表题解](linkedlist/leetcode61.md)
+
+[Leetcode160 相交链表题解](linkedlist/leetcode160.md)
+
+[Leetcode147 链表插入排序题解](linkedlist/leetcode147.md)

linkedlist/leetcode147.md

@@ -0,0 +1,50 @@
+### 描述
+
+对单链表进行插入排序。
+
+#### 什么是插入排序？
+
+插入排序其实也是一种很简单的排序方法，时间复杂度是O(n^2)。网上介绍这个排序算法的文章有很多，个人推荐去看算法导论的相关章节，讲的非常清楚。个人的理解是，类似我们平时玩扑克牌，手上有一把乱序的牌，每次我们拿一张牌出来，再看我们已经是有序的序列里面，我们找到他的位置，然后进行插入。（这也是它为什么叫插入排序？）
+
+附上原题链接：
+
+[点击此处查看原题](https://leetcode-cn.com/problems/insertion-sort-list/)
+
+### 思路
+
+这题思路比较简单，明白了插入排序我们就好下手了。
+
+这里主要是注意代码的写法。
+
+我们需要一个哨兵节点（dummy node）来保存头结点的信息。
+
+然后我们需要两个辅助节点来帮我们交换节点。话不多说，贴代码：
+
+```java
+public ListNode insertionSortList(ListNode head) {
+        if (head == null || head.next == null) return head;
+        ListNode dummy = new ListNode(0); // 哨兵节点的使用
+        dummy.next = head;
+        ListNode h1;
+        ListNode h2 = head.next;
+        head.next = null;
+        while (h2 != null) {
+            h1 = dummy;
+            // find the position.
+            while (h1.next != null && h1.next.val <= h2.val) {
+                h1 = h1.next;
+            }
+            ListNode nextTemp = h2.next;
+            h2.next = h1.next;
+            h1.next = h2;
+            h2 = nextTemp;
+
+        }
+        return dummy.next;
+    }
+```
+
+大致上就是这样，代码也比较简单，不懂的自己可以画个图来理解，感觉这几天的刷题还是对自己有点帮助的。多刷题就有进步。
+
+> > 愿在追梦路上的人都有收货！
+

linkedlist/leetcode160.md

@@ -0,0 +1,112 @@
+### 描述
+
+原题目是找到两个单链表的相交的起始节点。
+
+编写一个程序，找到两个单链表相交的起始节点。
+
+如下面的两个链表：
+
+
+
+在节点 c1 开始相交。
+
+ 
+
+示例 1：
+
+
+
+输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
+输出：Reference of the node with value = 8
+输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
+
+
+示例 2：
+
+
+
+输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
+输出：Reference of the node with value = 2
+输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
+
+
+示例 3：
+
+
+
+输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
+输出：null
+输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
+解释：这两个链表不相交，因此返回 null。
+
+[点击此处来查看原题](https://leetcode-cn.com/problems/intersection-of-two-linked-lists/)
+
+### 思路
+
+这题有很多思路，比较暴力的就是对于每个节点来进行一次遍历。
+
+时间复杂度：O(mn)
+
+空间复杂度: O(1)
+
+还有一种思路就是哈希表，使用哈希表来存储节点，来找到交点。
+
+时间复杂度：O(m+n)
+
+空间复杂度: O(m+n)
+
+比较好玩的是第三中思路，快慢指针。
+
+附上我的奇葩思路。。。
+
+```java
+public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
+        int lengthA = 0, lengthB = 0;
+        ListNode tA = headA;
+        ListNode tB = headB;
+        // get the length
+        while (tA != null) {
+            tA = tA.next;
+            lengthA++;
+        }
+        while (tB != null) {
+            tB = tB.next;
+            lengthB++;
+        }
+        if (lengthA >= lengthB) {
+            // let it move lengthA - lengthB steps.
+            int step = lengthA - lengthB;
+            
+            for (int i = 0; i < step; i++) {
+                headA = headA.next;
+            }            
+            // then lets go.
+            for (int i = step; i < lengthA; i++) {
+                if (headA == headB) {
+                    return headB;
+                }
+                headA = headA.next;
+                headB = headB.next;
+            }
+            return null;
+        }else {
+            // let it move lengthA - lengthB steps.
+            int step = lengthB - lengthA;
+            
+            for (int i = 0; i < step; i++) {
+                headB = headB.next;
+            }
+            // then lets go.
+            for (int i = step; i < lengthB; i++) {
+                if (headA == headB) {
+                    return headA;
+                }
+                headA = headA.next;
+                headB = headB.next;
+            }
+            return null;
+        }
+    }
+```
+
+代码有点臭， 但是思路应该很明白了。。。。