first commit

Author: xwk1246

.gitignore

@@ -0,0 +1,2 @@
+*
+!*.*

1.cpp

@@ -0,0 +1,17 @@
+#include <vector>
+#include <unordered_map>
+#include <unordered_set>
+#include <cmath>
+using namespace std;
+
+vector<int> twoSum(vector<int>& nums, int target) {
+    unordered_map<int, int>record;
+    for (int i = 0; i < nums.size(); i++) {
+        unordered_map<int, int>::iterator result;
+        if ((result = record.find(target - nums[i])) != record.end()) {
+            return { i, result->second };
+        }
+        record.insert(pair<int, int>(nums[i], i));
+    }
+    return {};
+}

142.cpp

@@ -0,0 +1,19 @@
+#include <iostream>
+
+ListNode* detectCycle(ListNode* head) {
+    ListNode* slow = head;
+    ListNode* fast = head;
+    while (fast->next && fast->next->next) {
+        fast = fast->next->next;
+        slow = slow->next;
+        if (fast == slow) {
+            slow = head;
+            while (fast != slow) {
+                fast = fast->next;
+                slow = slow->next;
+            }
+            return fast;
+        }
+    }
+    return nullptr;
+}

160.cpp

@@ -0,0 +1,51 @@
+#include <iostream>
+using namespace std;
+
+struct ListNode {
+    int val;
+    ListNode* next;
+    ListNode() {}
+    ListNode(int x) :val(x), next(nullptr) {}
+    ListNode(int x, ListNode* next) :val(x), next(next) {}
+};
+
+ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
+    int sizeA = 0, sizeB = 0;
+    ListNode* ptrA = new ListNode();
+    ptrA->next = headA;
+    ListNode* ptrB = new ListNode();
+    ptrB->next = headB;
+    ListNode* tmp = ptrA;
+    while (tmp->next) {
+        sizeA++;
+        tmp = tmp->next;
+    }
+    tmp = ptrB;
+    while (tmp->next) {
+        sizeB++;
+        tmp = tmp->next;
+    }
+    if (sizeA > sizeB) {
+        for (int i = 0; i < sizeA - sizeB; i++) {
+            ptrA = ptrA->next;
+        }
+    }
+    else if (sizeB > sizeA) {
+        for (int i = 0; i < sizeB - sizeA; i++) {
+            ptrB = ptrB->next;
+        }
+    }
+    while (ptrA && ptrB) {
+        if (ptrA == ptrB)return ptrA;
+        ptrA = ptrA->next;
+        ptrB = ptrB->next;
+    }
+    return nullptr;
+}
+
+int main() {
+    ListNode* tmp;
+    ListNode* headA = new ListNode(0, tmp = new ListNode(1, new ListNode(2)));
+    ListNode* headB = new ListNode(5, new ListNode(4, tmp));
+    cout << getIntersectionNode(headA, headB);
+}

19.cpp

@@ -0,0 +1,32 @@
+#include <iostream>
+using namespace std;
+
+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) {}
+};
+
+ListNode* removeNthFromEnd(ListNode* head, int n) {
+    ListNode* dummy = new ListNode(0, head);
+    ListNode* fast = dummy;
+    ListNode* slow = dummy;
+    for (int i = 0; i < n + 1; i++) {
+        fast = fast->next;
+    }
+    while (fast) {
+        fast = fast->next;
+        slow = slow->next;
+    }
+    ListNode* tmp = slow->next;
+    slow->next = slow->next->next;
+    delete tmp;
+    return dummy->next;
+}
+
+int main() {
+    ListNode* head = new ListNode(1, new ListNode(2, new ListNode(3)));
+    cout << removeNthFromEnd(head, 3)->val;
+}

202.cpp

@@ -0,0 +1,26 @@
+#include <iostream>
+#include <vector>
+#include <unordered_set>
+using namespace std;
+
+bool isHappy(int n) {
+    unordered_set<int>record;
+    int tmp = n;
+    int sum = 0;
+    while (sum != 1) {
+        sum = 0;
+        while (tmp) {
+            sum += (tmp % 10) * (tmp % 10);
+            tmp /= 10;
+        }
+        tmp = sum;
+        if (record.find(sum) != record.end())return false;
+        record.insert(sum);
+    }
+    return true;
+}
+
+int main() {
+    cout << isHappy(2);
+    return 0;
+}

203.cpp

@@ -0,0 +1,35 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+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) {}
+};
+
+ListNode* removeElements(ListNode* head, int val) {
+    ListNode* tmp;
+    ListNode* dummy = new ListNode(0, head);
+    ListNode* current = dummy;
+    while (current->next) {
+        if (current->next->val == val) {
+            tmp = current->next;
+            current->next = current->next->next;
+            delete tmp;
+        }
+        else {
+            current = current->next;
+        }
+    }
+    return dummy->next;
+}
+
+
+int main() {
+    ListNode* head = new ListNode(1, new ListNode(2, new ListNode(3, nullptr)));
+    removeElements(head, 2);
+    return 0;
+}

206.cpp

@@ -0,0 +1,19 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+ListNode* reverse(ListNode last, ListNode cur) {
+    if (cur)return last;
+    ListNode* tmp;
+    tmp = cur->next;
+    cur->next = last;
+    return reverse(cur, tmp);
+}
+
+ListNode* reverseList(ListNode* head) {
+    reverse(nullptr, cent nodes and return its head.You must solve the problem without modifying the values in the list's nodehead)
+}
+
+int main() {
+    return 0;
+}

209.cpp

@@ -0,0 +1,30 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+int minSubArrayLen(int target, vector<int>& nums) {
+    int min = 0;
+    int sum, tmp;
+    int i = 0;
+    int j = 0;
+    int k;
+    while (i < nums.size() && j < nums.size()) {
+        sum = 0;
+        for (k = i; k <= j; k++) {
+            sum += nums[k];
+        }
+        if (sum >= target && (j - i + 1 < min || min == 0))min = j - i + 1;
+        if (sum >= target) {
+            i++;
+        }
+        else if (sum < target) {
+            j++;
+        }
+    }
+    return min;
+}
+int main() {
+    vector <int> max = { 2,3,1,2,4,3 };
+    int target = 7;
+    cout << minSubArrayLen(target, max);
+}

24.cpp

@@ -0,0 +1,30 @@
+#include <iostream>
+using namespace std;
+
+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) {}
+};
+
+ListNode* swapPairs(ListNode* head) {
+    ListNode* dummy = new ListNode(0, head);
+    ListNode* cur = dummy;
+    ListNode* tmp;
+    while (cur->next && cur->next->next) {
+        tmp = cur->next->next;
+        cur->next->next = cur->next->next->next;
+        tmp->next = cur->next;
+        cur->next = tmp;
+        cur = cur->next->next;
+    }
+    return dummy->next;
+}
+
+int main() {
+    ListNode* head = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4))));
+    ListNode* swapped = swapPairs(head);
+    return 0;
+}