feat: update solutions to lcci problem: No.02.01. Remove Duplicate Node

Author: yanglbme

lcci/02.01.Remove Duplicate Node/README.md

@@ -86,18 +86,16 @@ class Solution {
         }
         Set<Integer> s = new HashSet<>();
         s.add(head.val);
-        ListNode p = head.next, cur = head;
-        while (p != null) {
+        ListNode cur = head;
+        for (ListNode p = head.next; p != null; p = p.next) {
             if (!s.contains(p.val)) {
                 cur.next = p;
                 cur = cur.next;
                 s.add(p.val);
             }
-            p = p.next;
         }
         cur.next = null;
         return head;
-
     }
 }
 ```
@@ -134,6 +132,38 @@ class Solution {
 };
 ```
 
+### **C++**
+
+```cpp
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* removeDuplicateNodes(ListNode* head) {
+        if (head == nullptr || head->next == nullptr) {
+            return head;
+        }
+        unordered_set<int> cache = {head->val};
+        ListNode *cur = head;
+        for (ListNode *p = head->next; p != nullptr; p = p->next) {
+            if (!cache.count(p->val)) {
+                cur->next = p;
+                cur = cur->next;
+                cache.insert(p->val);
+            }
+        }
+        cur->next = nullptr;
+        return head;
+    }
+};
+```
+
 ### **...**
 
 ```

lcci/02.01.Remove Duplicate Node/README_EN.md

@@ -30,7 +30,6 @@
 
 <ol>
 	<li>The length of the list is within the range[0, 20000].</li>
-
     <li>The values of the list elements are within the range [0, 20000].</li>
 
 </ol>
@@ -87,18 +86,16 @@ class Solution {
         }
         Set<Integer> s = new HashSet<>();
         s.add(head.val);
-        ListNode p = head.next, cur = head;
-        while (p != null) {
+        ListNode cur = head;
+        for (ListNode p = head.next; p != null; p = p.next) {
             if (!s.contains(p.val)) {
                 cur.next = p;
                 cur = cur.next;
                 s.add(p.val);
             }
-            p = p.next;
         }
         cur.next = null;
         return head;
-
     }
 }
 ```
@@ -135,6 +132,38 @@ class Solution {
 };
 ```
 
+### **C++**
+
+```cpp
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* removeDuplicateNodes(ListNode* head) {
+        if (head == nullptr || head->next == nullptr) {
+            return head;
+        }
+        unordered_set<int> cache = {head->val};
+        ListNode *cur = head;
+        for (ListNode *p = head->next; p != nullptr; p = p->next) {
+            if (!cache.count(p->val)) {
+                cur->next = p;
+                cur = cur->next;
+                cache.insert(p->val);
+            }
+        }
+        cur->next = nullptr;
+        return head;
+    }
+};
+```
+
 ### **...**
 
 ```

lcci/02.01.Remove Duplicate Node/Solution.cpp

@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* removeDuplicateNodes(ListNode* head) {
+        if (head == nullptr || head->next == nullptr) {
+            return head;
+        }
+        unordered_set<int> cache = {head->val};
+        ListNode *cur = head;
+        for (ListNode *p = head->next; p != nullptr; p = p->next) {
+            if (!cache.count(p->val)) {
+                cur->next = p;
+                cur = cur->next;
+                cache.insert(p->val);
+            }
+        }
+        cur->next = nullptr;
+        return head;
+    }
+};

lcci/02.01.Remove Duplicate Node/Solution.java

@@ -13,17 +13,15 @@ public ListNode removeDuplicateNodes(ListNode head) {
         }
         Set<Integer> s = new HashSet<>();
         s.add(head.val);
-        ListNode p = head.next, cur = head;
-        while (p != null) {
+        ListNode cur = head;
+        for (ListNode p = head.next; p != null; p = p.next) {
             if (!s.contains(p.val)) {
                 cur.next = p;
                 cur = cur.next;
                 s.add(p.val);
             }
-            p = p.next;
         }
         cur.next = null;
         return head;
-
     }
 }