2019-5-23

Author: JiayangWu

0002.两数相加/0002-两数相加.cpp

@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
+        ListNode* res = new ListNode(-1);
+        ListNode* cur = res;
+        int carry = 0;
+        while(l1 || l2){
+            int t1 = l1? l1->val : 0;
+            int t2 = l2? l2->val : 0;
+            int sum = t1 + t2 + carry;
+            carry = sum / 10;
+            cur->next = new ListNode(sum % 10);
+            cur = cur->next;
+            if (l1) l1 = l1->next;
+            if (l2) l2 = l2->next;
+        }
+        if (carry) cur->next =new ListNode(1);
+        return res->next;
+        
+        
+    }
+};

0003.无重复字符的最长子串/0003-无重复字符的最长子串.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+    
+        string dic = "";
+        int ans = 0;
+        int i = 0;
+        int j = 0;
+        int l = s.size();
+        while( i < l && j < l ){
+            char a = s[i];
+            char b = s[j];
+            // cout<<dic.find(b)<<endl;
+            if (dic.find(b) >= 0 && dic.find(b) < 99999999){
+                i += 1;
+                dic.erase(0, 1); 
+            }
+            else{
+                j += 1;
+                dic.push_back(b);
+                // cout << "Dasdas" << endl;
+            }
+            ans = ans < j-i ? j-i : ans;
+            // cout <<i<<" "<<j << endl;
+        }
+        return ans;
+    }
+};

0009.回文数/0009-回文数.py

@@ -0,0 +1,11 @@
+class Solution(object):
+    def isPalindrome(self, x):
+
+        s = str(x)
+        if len(s) <= 1:
+            return True
+        print len(s) / 2
+        for count in range(0, len(s)/2):
+            if s[count] != s[len(s)-1  - count]:
+                return False
+        return True

0019.删除链表的倒数第N个节点/0019-删除链表的倒数第N个节点.py

@@ -0,0 +1,33 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def removeNthFromEnd(self, head, n):
+        """
+        :type head: ListNode
+        :type n: int
+        :rtype: ListNode
+        """
+        if not head.next:
+            return []
+        p = head
+        if n == 1:
+            while(p.next.next):
+                p = p.next
+            p.next = None
+        else:
+            fast = head
+            slow = head
+            for i in range(n-1):
+                fast = fast.next
+            print fast.val,slow.val
+            while(fast.next):
+                fast = fast.next
+                slow = slow.next
+            print fast.val,slow.val 
+            slow.val = slow.next.val
+            slow.next = slow.next.next
+        return head

0020.有效的括号/0020-有效的括号.py

@@ -0,0 +1,16 @@
+class Solution(object):
+    def isValid(self, s):
+        """
+        :type s: str
+        :rtype: bool
+        """
+        if len(s)%2:
+            return False
+        dic = {")":"(","]":"[","}":"{"}
+        stack = [None]
+        for item in s:
+            if item in dic and stack[-1] == dic[item]:
+                stack.pop()
+            else:
+                stack.append(item)
+        return len(stack) == 1

0021.合并两个有序链表/0021-合并两个有序链表.cpp

@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
+        ListNode temp_head(0);
+        ListNode* pre = &temp_head;
+        while(l1 && l2){
+            if (l1->val<= l2->val){
+                pre->next = l1;
+                l1 = l1->next;
+            }
+            else{
+                pre->next = l2;
+                l2 = l2->next;
+            }
+            pre = pre->next;
+        }
+        if(l1) pre->next = l1;
+        if(l2) pre->next = l2;
+        return temp_head.next;
+        
+    }
+};

0022.括号生成/0022-括号生成.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    def generate(self, temp, left, right, result):
+        if (left == 0 and right == 0):
+            result.append(temp)
+            return
+        if (left > 0):
+            self.generate(temp + "(", left-1, right, result)
+        if (left < right):
+            self.generate(temp + ")", left, right - 1, result)
+            
+    def generateParenthesis(self, n):
+        """
+        :type n: int
+        :rtype: List[str]
+        """
+        result = []
+        self.generate("", n, n, result)
+        return result
+    
+
+            
+        
+        

0023.合并K个排序链表/0023-合并K个排序链表.cpp

@@ -0,0 +1,35 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+bool cmp(const ListNode* a, const ListNode* b){
+    return a->val < b->val;
+}
+class Solution {
+public:
+    ListNode* mergeKLists(vector<ListNode*>& lists) {
+        std::vector<ListNode *> value;
+        for(int i = 0; i< lists.size(); ++i){
+            ListNode* head = lists[i];
+            while(head){
+                value.push_back(head);
+                head = head->next;
+            }
+        }
+        
+        std::sort(value.begin(),value.end(), cmp);
+        if (value.size() == 0)
+            return NULL;
+        
+        for(int i = 1; i<value.size(); ++i){
+            value[i-1]->next = value[i];
+        }
+        value[value.size()-1]->next = NULL;
+        return value[0];
+        
+    }
+};

0024.两两交换链表中的节点/0024-两两交换链表中的节点.cpp

@@ -0,0 +1,31 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* swapPairs(ListNode* head) {
+        if (!head || !head->next)
+            return head;
+        ListNode n_head(0);
+        ListNode* pre = &n_head;
+        n_head.next = head;
+        ListNode* ptr = head;
+        while(ptr && ptr->next){
+            pre->next = ptr->next;
+            // if (!ptr->next)
+            ptr->next = ptr->next->next;
+            // else
+                // ptr->next = NULL;
+            pre->next->next = ptr;
+            pre = pre->next->next;
+            ptr = ptr->next;
+        }
+        return n_head.next;
+        
+    }
+};

0028.实现strStr()/0028-实现strStr().cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int strStr(string haystack, string needle) {
+        if (needle.size() == 0){
+            return 0;
+        }
+        int lh = haystack.size();
+        int ln = needle.size();
+        bool flag = 0;
+        for (int i = 0; i <=lh - ln ; ++i){
+            flag = 1;
+            for (int j = i; j < i + ln; ++ j){
+                if (haystack[j] != needle[j-i]){
+                    flag = 0;
+                    break;
+                }
+            }
+            if (flag) return i;
+        }
+        if (!flag) return -1;
+    }
+    
+};