链表专题更新cpp代码

Author: coderhare

animation-simulation/链表篇/234. 回文链表.md

@@ -33,6 +33,8 @@
 
 我们首先将链表的所有元素都保存在数组中，然后再利用双指针遍历数组，进而来判断是否为回文。这个方法很容易理解，而且代码实现也比较简单。
 
+**题目代码**
+
 ```java
 class Solution {
     public boolean isPalindrome(ListNode head) {
@@ -72,6 +74,10 @@ class Solution {
 
 ![翻转链表部分](https://cdn.jsdelivr.net/gh/tan45du/photobed@master/photo/翻转链表部分.1v2ncl72ligw.gif)
 
+#### **题目代码**
+
+Java Code：
+
 ```java
 class Solution {
     public boolean isPalindrome(ListNode head) {
@@ -129,3 +135,63 @@ class Solution {
 }
 ```
 
+C++ Code：
+
+```cpp
+class Solution {
+public:
+    bool isPalindrome(ListNode* head) {
+        if (head == nullptr || head->next == nullptr) {
+              return true;
+         }
+         //找到中间节点，也就是翻转的头节点,这个在昨天的题目中讲到
+         //但是今天和昨天有一些不一样的地方就是，如果有两个中间节点返回第一个，昨天的题目是第二个
+         ListNode * midenode =  searchmidnode(head);
+         //原地翻转链表，需要两个辅助指针。这个也是面试题目，大家可以做一下
+         //这里我们用的是midnode->next需要注意，因为我们找到的是中点，但是我们翻转的是后半部分
+         
+         ListNode * backhalf = reverse(midenode->next);
+         //遍历两部分链表，判断值是否相等
+         ListNode * p1 = head;
+         ListNode * p2 = backhalf;         
+         while (p2 != nullptr) {
+            if (p1->val != p2->val) {
+               return false;
+            }
+            p1 = p1->next;
+            p2 = p2->next;
+        }        
+        // 还原链表并返回结果,这一步是需要注意的，我们不可以破坏初始结构，我们只是判断是否为回文，
+        //当然如果没有这一步也是可以AC，但是面试的时候题目要求可能会有这一条。
+        midenode->next = reverse(backhalf);
+        return true;       
+    }
+    //找到中间的部分
+    ListNode * searchmidnode (ListNode * head) {       
+          ListNode * fast = new ListNode(-1);
+          ListNode * slow = new ListNode(-1);
+          fast = head;
+          slow = head;
+          //找到中点
+          while (fast->next != nullptr && fast->next->next != nullptr) {
+              fast = fast->next->next;
+              slow = slow->next;
+          }       
+          return slow;
+    }
+    //翻转链表
+    ListNode * reverse (ListNode * slow) {
+          ListNode * low  = nullptr;
+          ListNode * temp = nullptr;
+          //翻转链表
+          while (slow != nullptr) {
+                  temp = slow->next;
+                  slow->next = low;
+                  low = slow;
+                  slow = temp;
+          }
+          return low;
+    }
+};
+```
+

animation-simulation/链表篇/leetcode141环形链表.md

@@ -72,3 +72,24 @@ var hasCycle = function(head) {
     return false;
 };
 ```
+
+C++ Code:
+
+```cpp
+class Solution {
+public:
+    bool hasCycle(ListNode *head) {
+         ListNode * fast = head;
+         ListNode * low = head;
+         while (fast != nullptr && fast->next != nullptr) {
+             fast = fast->next->next;
+             low = low->next;
+             if (fast == low) {
+                 return true;
+             }
+         }
+         return false;
+    }
+};
+```
+

animation-simulation/链表篇/leetcode142环形链表2.md

@@ -123,7 +123,9 @@ public class Solution {
 
 ![环形链表2](https://cdn.jsdelivr.net/gh/tan45du/photobed@master/photo/环形链表2.elwu1pw2lw0.gif)
 
+**题目代码**
 
+Java Code:
 
 ```java
 public class Solution {
@@ -153,3 +155,34 @@ public class Solution {
 }
 ```
 
+C++ Code:
+
+```cpp
+class Solution {
+public:
+    ListNode *detectCycle(ListNode *head) {
+        //快慢指针
+        ListNode * fast = head;
+        ListNode * low  = head;
+        //设置循环条件
+        while (fast != nullptr && fast->next != nullptr) {
+            fast = fast->next->next;
+            low = low->next;
+            //相遇
+            if (fast == low) {
+                //设置一个新的指针，从头节点出发，慢指针速度为1，所以可以使用慢指针从相遇点出发
+                ListNode * newnode = head;
+                while (newnode != low) {        
+                    low = low->next;
+                    newnode = newnode->next;
+                }
+                //在环入口相遇
+                return low;
+            }
+        } 
+        return nullptr;
+        
+    }
+};
+```
+

animation-simulation/链表篇/leetcode147对链表进行插入排序.md

@@ -82,6 +82,8 @@
 
 **题目代码**
 
+Java Code:
+
 ```java
 class Solution {
     public ListNode insertionSortList(ListNode head) {
@@ -121,7 +123,45 @@ class Solution {
 }
 ```
 
- 
+ C++ Code:
+
+```cpp
+class Solution {
+public:
+    ListNode* insertionSortList(ListNode* head) {
+        if (head == nullptr && head->next == nullptr) {
+            return head;
+        }
+        //哑节点
+        ListNode * dummyNode = new ListNode(-1);
+        dummyNode->next = head;
+        //pre负责指向新元素，last 负责指向新元素的前一元素
+        //判断是否需要执行插入操作
+        ListNode * pre = head->next;
+        ListNode * last = head;
+        ListNode * temphead = dummyNode;
+        while (pre != nullptr) {
+            //不需要插入到合适位置，则继续往下移动
+            if (last->val <= pre->val) {
+                pre = pre->next;
+                last = last->next;
+                continue;
+            }               
+            //开始出发，查找新元素的合适位置
+            temphead = dummyNode;
+            while (temphead->next->val <= pre->val) {
+                temphead = temphead->next;
+            }           
+            //此时我们已经找到了合适位置，我们需要进行插入，大家可以画一画
+            last->next = pre->next;
+            pre->next = temphead->next;
+            temphead->next = pre;
+            pre = last->next;
+        }
+        return dummyNode->next;
+    }
+};
+```
 
 
 

animation-simulation/链表篇/leetcode206反转链表.md

@@ -33,6 +33,10 @@ low = temp 即可。然后重复执行上诉操作直至最后，这样则完成
 
 我会对每个关键点进行注释，大家可以参考动图理解。
 
+
+
+**题目代码**
+
 Java Code:
 ```java
 class Solution {
@@ -81,8 +85,44 @@ var reverseList = function(head) {
 };
 ```
 
+C++代码
+
+```cpp
+class Solution {
+public:
+    ListNode* reverseList(ListNode* head) {
+         //特殊情况
+        if (head == nullptr || head->next == nullptr) {
+            return head;
+        }
+        //反转
+        return reverse(head);
+    }
+    ListNode * reverse (ListNode * head) {
+        
+        ListNode * low = nullptr;
+        ListNode * pro = head;
+        while (pro != nullptr) {
+            //代表橙色指针
+            ListNode * temp = pro;
+            //移动绿色指针
+            pro = pro->next;
+            //反转节点
+            temp->next = low;
+            //移动黄色指针
+            low = temp;
+        }     
+        return low;
+    }
+};
+```
+
 上面的迭代写法是不是搞懂啦，现在还有一种递归写法，不是特别容易理解，刚开始刷题的同学，可以只看迭代解法。
 
+
+
+**题目代码**
+
 Java Code:
 ```java
 class Solution {
@@ -118,3 +158,26 @@ var reverseList = function(head) {
 };
 ```
 
+C++代码:
+
+```cpp
+class Solution {
+public:
+    ListNode * reverseList(ListNode * head) {
+        //结束条件
+        if (head == nullptr || head->next == nullptr) {
+            return head;
+        }
+        //保存最后一个节点
+        ListNode * pro = reverseList(head->next);
+        //将节点进行反转。我们可以这样理解 4->next->next = 4;
+        //4->next = 5；
+        //则 5->next = 4 则实现了反转
+        head->next->next = head;
+        //防止循环
+        head->next = nullptr;
+        return pro;
+    }
+};
+```
+

animation-simulation/链表篇/leetcode328奇偶链表.md

@@ -36,6 +36,8 @@
 
 #### 题目代码
 
+Java Code:
+
 ```java
 class Solution {
     public ListNode oddEvenList(ListNode head) {
@@ -60,3 +62,30 @@ class Solution {
 }
 ```
 
+C++ Code:
+
+```cpp
+class Solution {
+public:
+    ListNode* oddEvenList(ListNode* head) {
+         if (head == nullptr || head->next == nullptr) {
+             return head;
+         }
+         ListNode * odd = head;
+         ListNode * even = head->next;
+         ListNode * evenhead = even;
+
+         while (odd->next != nullptr && even->next != nullptr) {
+             //将偶数位合在一起，奇数位合在一起
+             odd->next = even->next;
+             odd = odd->next;
+             even->next = odd->next;
+             even = even->next;
+         }  
+         //链接
+         odd->next = evenhead;
+         return head;
+    }
+};
+```
+

animation-simulation/链表篇/leetcode82删除排序链表中的重复元素II.md

@@ -39,6 +39,10 @@
 
 ![删除重复节点2](https://cdn.jsdelivr.net/gh/tan45du/photobed@master/photo/删除重复节点2.3btmii5cgxa0.gif)
 
+**题目代码**
+
+Java Code:
+
 ```java
 class Solution {
     public ListNode deleteDuplicates(ListNode head) {
@@ -68,3 +72,35 @@ class Solution {
 }
 ```
 
+C++ Code:
+
+```cpp
+class Solution {
+public:
+    ListNode* deleteDuplicates(ListNode* head) {
+        if(head == nullptr || head->next == nullptr){
+            return head;
+        }
+        ListNode * pre = head;
+        ListNode * low = new ListNode(0);
+        low->next = pre;
+        ListNode * ret = new ListNode(-1);
+        ret = low;
+        while(pre != nullptr && pre->next != nullptr) {
+            if (pre->val == pre->next->val) {
+                while (pre != nullptr && pre->next != nullptr && pre->val == pre->next->val) {
+                    pre = pre->next;
+                }
+                pre = pre->next;
+                low->next = pre;                     
+             }
+             else{
+                 pre = pre->next;
+                 low = low->next;
+             }
+        }
+     return ret->next;
+    }
+};
+```
+