添加题目63

Author: SherlockUnknowEn

60-69/62. Intersection of Two Linked Lists(Easy)/README.md

@@ -5,6 +5,7 @@
 给你两个单链表的头节点 `headA` 和 `headB` ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 `null` 。
 
 图示两个链表在节点 `c1` 开始相交：
+
 ![160_statement.png](https://github.com/SherlockUnknowEn/leetcode/blob/master/60-69/62.%20Intersection%20of%20Two%20Linked%20Lists(Easy)/160_statement.png)
 
 题目数据 保证 整个链式结构中不存在环。
@@ -30,6 +31,7 @@
 Given the heads of two singly linked-lists `headA` and `headB`, return the node at which the two lists intersect. If the two linked lists have no intersection at all, return `null`.
 
 For example, the following two linked lists begin to intersect at node `c1`:
+
 ![160_statement.png](https://github.com/SherlockUnknowEn/leetcode/blob/master/60-69/62.%20Intersection%20of%20Two%20Linked%20Lists(Easy)/160_statement.png)
 
 The test cases are generated such that there are no cycles anywhere in the entire linked structure.
@@ -55,8 +57,10 @@ The judge will then create the linked structure based on these inputs and pass t
 
 
 **example 1**
+
 ![160_example_1.png](https://github.com/SherlockUnknowEn/leetcode/blob/master/60-69/62.%20Intersection%20of%20Two%20Linked%20Lists(Easy)/160_example_1.png)
 
+
 ```
 Input: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
 Output: Intersected at '8'
@@ -67,8 +71,10 @@ From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,
 
 
 **example 2**
+
 ![160_example_2.png](https://github.com/SherlockUnknowEn/leetcode/blob/master/60-69/62.%20Intersection%20of%20Two%20Linked%20Lists(Easy)/160_example_2.png)
 
+
 ```
 Input: intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
 Output: Intersected at '2'
@@ -78,8 +84,10 @@ From the head of A, it reads as [1,9,1,2,4]. From the head of B, it reads as [3,
 ```
 
 **example 3**
+
 ![160_example_3.png](https://github.com/SherlockUnknowEn/leetcode/blob/master/60-69/62.%20Intersection%20of%20Two%20Linked%20Lists(Easy)/160_example_3.png)
 
+
 ```
 Input: intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
 Output: No intersection
@@ -116,6 +124,7 @@ intersectVal == listA[skipA] == listB[skipB] if listA and listB intersect.
 1. 解决这个问题的关键是，通过某些方式，让 `p1` 和 `p2` 能够同时到达相交节点 `c1`
 2. 我们可以让 `p1` 遍历完链表 `A` 之后开始遍历链表 `B`，让 `p2` 遍历完链表 `B` 之后开始遍历链表 `A`，这样相当于「逻辑上」两条链表接在了一起。如果这样进行拼接，就可以让 `p1` 和 `p2` 同时进入公共部分，也就是同时到达相交节点 `c1`
 3. 具体原理如下图
+
 ![img](https://github.com/SherlockUnknowEn/leetcode/blob/master/60-69/62.%20Intersection%20of%20Two%20Linked%20Lists(Easy)/2.jpeg)
 
 

60-69/63. Middle of the Linked List(Easy)/876.middle-of-the-linked-list.cpp

@@ -0,0 +1,38 @@
+/*
+ * @lc app=leetcode id=876 lang=cpp
+ *
+ * [876] Middle of the Linked List
+ */
+
+// @lc code=start
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* middleNode(ListNode* head) {
+        if (head == nullptr)
+            return head;
+        ListNode *fast, *slow;
+        fast = slow = head;
+        while (fast->next != nullptr && fast->next->next != nullptr)
+        {
+            fast = fast->next->next;
+            slow = slow->next;
+        }
+        // 偶数个
+        if (fast->next != nullptr && fast->next->next == nullptr)
+            return slow->next;
+        else 
+            return slow;        
+    }
+};
+// @lc code=end
+

60-69/63. Middle of the Linked List(Easy)/README.md

@@ -0,0 +1,105 @@
+# 链表的中间结点
+
+#### *Middle of the Linked List*
+
+给定一个头结点为 head 的非空单链表，返回链表的中间结点。
+
+如果有两个中间结点，则返回第二个中间结点。
+
+提示：
+
+给定链表的结点数介于 1 和 100 之间。
+
+
+英文题目:
+
+Given the head of a singly linked list, return the middle node of the linked list.
+
+If there are two middle nodes, return the `second middle` node.
+
+ 
+
+**example 1**
+
+![test 1](https://github.com/SherlockUnknowEn/leetcode/blob/master/60-69/63.%20Middle%of%the%Linked%List(Easy)/lc-midlist1.jpg)
+
+```
+Input: head = [1,2,3,4,5]
+Output: [3,4,5]
+Explanation: The middle node of the list is node 3.
+
+```
+
+
+**example 2**
+
+![test 2](https://github.com/SherlockUnknowEn/leetcode/blob/master/60-69/63.%20Middle%of%the%Linked%List(Easy)/lc-midlist2.jpg)
+
+```
+Input: head = [1,2,3,4,5,6]
+Output: [4,5,6]
+Explanation: Since the list has two middle nodes with values 3 and 4, we return the second one.
+
+```
+
+
+
+**Constraints:**
+
+The number of nodes in the list is in the range `[1, 100]`.
+
+1 <= `Node.val` <= 100
+
+---
+
+### 思路
+
+1. 使用快慢两个指针，快指针每次走2步，慢指针每次走1步，当快指针到达链表尾部时，慢指针指向链表中点
+2. 注意处理链表长度为偶数的情况
+
+
+### 代码
+```
+
+/*
+ * @lc app=leetcode id=876 lang=cpp
+ *
+ * [876] Middle of the Linked List
+ */
+
+// @lc code=start
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* middleNode(ListNode* head) {
+        if (head == nullptr)
+            return head;
+        ListNode *fast, *slow;
+        fast = slow = head;
+        while (fast->next != nullptr && fast->next->next != nullptr)
+        {
+            fast = fast->next->next;
+            slow = slow->next;
+        }
+        // 偶数个
+        if (fast->next != nullptr && fast->next->next == nullptr)
+            return slow->next;
+        else 
+            return slow;        
+    }
+};
+// @lc code=end
+
+
+```
+
+本题以及其它leetcode题目代码github地址: [github地址](https:github.com/SherlockUnknowEn/leetcode)

60-69/63. Middle of the Linked List(Easy)/lc-midlist1.jpg

@@ -58,5 +58,6 @@
 ##### 58. [79.Word Search](https://github.com/SherlockUnknowEn/leetcode/tree/master/50-59/58.%20Word%20Search(Medium)) 单词搜索
 ##### 59. [80.Remove Duplicates from Sorted Array II](https://github.com/SherlockUnknowEn/leetcode/tree/master/50-59/59.%20Remove%20Duplicates%20from%20Sorted%20Array%20II(Medium)) 删除排序数组中的重复项 II
 ##### 60. [141.Linked List Cycle](https://github.com/SherlockUnknowEn/leetcode/tree/master/60-69/60.%20Linked%20List%20Cycle(Easy)) 环形链表
-##### 61. [142.Linked List Cycle II](https://github.com/SherlockUnknowEn/leetcode/tree/master/60-69/61.%20Linked%20List%20Cycle%20II(Medium)) 环形链表2
-##### 62. [160.Intersection of Two Linked Lists](https://github.com/SherlockUnknowEn/leetcode/tree/master/60-69/62.%20Intersection%20of%20Two%20Linked%20Lists(Easy)) 环形链表2
+##### 61. [142.Linked List Cycle II](https://github.com/SherlockUnknowEn/leetcode/tree/master/60-69/61.%20Linked%20List%20Cycle%20II(Medium)) 环形链表 II
+##### 62. [160.Intersection of Two Linked Lists](https://github.com/SherlockUnknowEn/leetcode/tree/master/60-69/62.%20Intersection%20of%20Two%20Linked%20Lists(Easy)) 相交链表
+##### 63. [876.Middle of the Linked List](https://github.com/SherlockUnknowEn/leetcode/tree/master/60-69/63.%20Middle%of%the%Linked%List(Easy)) 链表的中间结点