feat: add cpp solution to lc problem: No.1836. Remove Duplicates From an Unsorted Linked List

Author: yanglbme

solution/1800-1899/1836.Remove Duplicates From an Unsorted Linked List/README.md

@@ -12,6 +12,8 @@ None
 
 <!-- 这里可写通用的实现逻辑 -->
 
+“哈希表”实现。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -60,15 +62,13 @@ class Solution:
  */
 class Solution {
     public ListNode deleteDuplicatesUnsorted(ListNode head) {
-        ListNode cur = head;
         Map<Integer, Integer> counter = new HashMap<>();
-        for (; cur != null; cur = cur.next) {
+        for (ListNode cur = head; cur != null; cur = cur.next) {
             counter.put(cur.val, counter.getOrDefault(cur.val, 0) + 1);
         }
 
         ListNode dummy = new ListNode(0, head);
-        ListNode pre = dummy;
-        for (cur = head; cur != null; cur = cur.next) {
+        for (ListNode pre = dummy, cur = head; cur != null; cur = cur.next) {
             if (counter.get(cur.val) > 1) {
                 pre.next = cur.next;
             } else {
@@ -80,6 +80,40 @@ class Solution {
 }
 ```
 
+### **C++**
+
+```cpp
+/**
+ * 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* deleteDuplicatesUnsorted(ListNode* head) {
+        unordered_map<int, int> counter;
+        for (ListNode* cur = head; cur != nullptr; cur = cur->next) {
+            ++counter[cur->val];
+        }
+
+        ListNode* dummy = new ListNode(0, head);
+        for (ListNode* pre = dummy, *cur = head; cur != nullptr; cur = cur->next) {
+            if (counter[cur->val] > 1) {
+                pre->next = cur->next;
+            } else {
+                pre = cur;
+            }
+        }
+        return dummy->next;
+    }
+};
+```
+
 ### **...**
 
 ```

solution/1800-1899/1836.Remove Duplicates From an Unsorted Linked List/README_EN.md

@@ -107,15 +107,13 @@ class Solution:
  */
 class Solution {
     public ListNode deleteDuplicatesUnsorted(ListNode head) {
-        ListNode cur = head;
         Map<Integer, Integer> counter = new HashMap<>();
-        for (; cur != null; cur = cur.next) {
+        for (ListNode cur = head; cur != null; cur = cur.next) {
             counter.put(cur.val, counter.getOrDefault(cur.val, 0) + 1);
         }
 
         ListNode dummy = new ListNode(0, head);
-        ListNode pre = dummy;
-        for (cur = head; cur != null; cur = cur.next) {
+        for (ListNode pre = dummy, cur = head; cur != null; cur = cur.next) {
             if (counter.get(cur.val) > 1) {
                 pre.next = cur.next;
             } else {
@@ -127,6 +125,40 @@ class Solution {
 }
 ```
 
+### **C++**
+
+```cpp
+/**
+ * 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* deleteDuplicatesUnsorted(ListNode* head) {
+        unordered_map<int, int> counter;
+        for (ListNode* cur = head; cur != nullptr; cur = cur->next) {
+            ++counter[cur->val];
+        }
+
+        ListNode* dummy = new ListNode(0, head);
+        for (ListNode* pre = dummy, *cur = head; cur != nullptr; cur = cur->next) {
+            if (counter[cur->val] > 1) {
+                pre->next = cur->next;
+            } else {
+                pre = cur;
+            }
+        }
+        return dummy->next;
+    }
+};
+```
+
 ### **...**
 
 ```

solution/1800-1899/1836.Remove Duplicates From an Unsorted Linked List/Solution.cpp

@@ -0,0 +1,29 @@
+/**
+ * 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* deleteDuplicatesUnsorted(ListNode* head) {
+        unordered_map<int, int> counter;
+        for (ListNode* cur = head; cur != nullptr; cur = cur->next) {
+            ++counter[cur->val];
+        }
+
+        ListNode* dummy = new ListNode(0, head);
+        for (ListNode* pre = dummy, *cur = head; cur != nullptr; cur = cur->next) {
+            if (counter[cur->val] > 1) {
+                pre->next = cur->next;
+            } else {
+                pre = cur;
+            }
+        }
+        return dummy->next;
+    }
+};

solution/1800-1899/1836.Remove Duplicates From an Unsorted Linked List/Solution.java

@@ -10,15 +10,13 @@
  */
 class Solution {
     public ListNode deleteDuplicatesUnsorted(ListNode head) {
-        ListNode cur = head;
         Map<Integer, Integer> counter = new HashMap<>();
-        for (; cur != null; cur = cur.next) {
+        for (ListNode cur = head; cur != null; cur = cur.next) {
             counter.put(cur.val, counter.getOrDefault(cur.val, 0) + 1);
         }
 
         ListNode dummy = new ListNode(0, head);
-        ListNode pre = dummy;
-        for (cur = head; cur != null; cur = cur.next) {
+        for (ListNode pre = dummy, cur = head; cur != null; cur = cur.next) {
             if (counter.get(cur.val) > 1) {
                 pre.next = cur.next;
             } else {