From 30bfcef198688e7216b8914537e2c55c9cccf21f Mon Sep 17 00:00:00 2001 From: hai dang Date: Thu, 26 Sep 2019 08:29:31 -0700 Subject: [PATCH] Update more leetcode solution --- leetcode/README.md | 18 ++++++++++++++++++ leetcode/src/109.c | 21 +++++++++++++++++++++ leetcode/src/112.c | 7 +++++++ leetcode/src/142.c | 19 +++++++++++++++++++ leetcode/src/153.c | 13 +++++++++++++ leetcode/src/160.c | 17 +++++++++++++++++ leetcode/src/203.c | 10 ++++++++++ leetcode/src/24.c | 9 +++++++++ leetcode/src/27.c | 8 ++++++++ leetcode/src/278.c | 15 +++++++++++++++ leetcode/src/283.c | 10 ++++++++++ leetcode/src/509.c | 7 +++++++ leetcode/src/53.c | 13 +++++++++++++ leetcode/src/674.c | 16 ++++++++++++++++ leetcode/src/82.c | 13 +++++++++++++ leetcode/src/83.c | 11 +++++++++++ leetcode/src/852.c | 13 +++++++++++++ leetcode/src/94.c | 15 +++++++++++++++ leetcode/src/977.c | 29 +++++++++++++++++++++++++++++ 19 files changed, 264 insertions(+) create mode 100644 leetcode/src/109.c create mode 100644 leetcode/src/112.c create mode 100644 leetcode/src/142.c create mode 100644 leetcode/src/153.c create mode 100644 leetcode/src/160.c create mode 100644 leetcode/src/203.c create mode 100644 leetcode/src/24.c create mode 100644 leetcode/src/27.c create mode 100644 leetcode/src/278.c create mode 100644 leetcode/src/283.c create mode 100644 leetcode/src/509.c create mode 100644 leetcode/src/53.c create mode 100644 leetcode/src/674.c create mode 100644 leetcode/src/82.c create mode 100644 leetcode/src/83.c create mode 100644 leetcode/src/852.c create mode 100644 leetcode/src/94.c create mode 100644 leetcode/src/977.c diff --git a/leetcode/README.md b/leetcode/README.md index ef27aa00..155d3f37 100644 --- a/leetcode/README.md +++ b/leetcode/README.md @@ -8,38 +8,56 @@ LeetCode |---| ----- | -------- | ---------- | |3|[Longest Substring Without Repeating Characters](https://leetcode.com/problems/longest-substring-without-repeating-characters/) | [C](./src/3.c)|Medium| |20|[Valid Parentheses](https://leetcode.com/problems/valid-parentheses/) | [C](./src/20.c)|Easy| +|27|[Remove Element](https://leetcode.com/problems/remove-element/) | [C](./src/27.c)|Easy| +|24|[Swap Nodes in Pairs](https://leetcode.com/problems/swap-nodes-in-pairs/) | [C](./src/24.c)|Medium| |26|[Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/) | [C](./src/26.c)|Easy| |35|[Search Insert Position](https://leetcode.com/problems/search-insert-position/) | [C](./src/35.c)|Easy| +|53|[Maximum Subarray](https://leetcode.com/problems/maximum-subarray/) | [C](./src/53.c)|Easy| +|82|[Remove Duplicates from Sorted List II](https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/) | [C](./src/82.c)|Medium| +|83|[Remove Duplicates from Sorted List](https://leetcode.com/problems/remove-duplicates-from-sorted-list/) | [C](./src/83.c)|Easy| +|94|[Binary Tree Inorder Traversal](https://leetcode.com/problems/binary-tree-inorder-traversal/) | [C](./src/94.c)|Medium| |101|[Symmetric Tree](https://leetcode.com/problems/symmetric-tree/) | [C](./src/101.c)|Easy| |104|[Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/) | [C](./src/104.c)|Easy| |108|[Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/) | [C](./src/108.c)|Easy| +|109|[Convert Sorted List to Binary Search Tree](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/) | [C](./src/109.c)|Medium| +|112|[Path Sum](https://leetcode.com/problems/path-sum/) | [C](./src/112.c)|Easy| |110|[Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree/) | [C](./src/110.c)|Easy| |125|[Valid Palindrome](https://leetcode.com/problems/valid-palindrome/) | [C](./src/125.c)|Easy| |136|[Single Number](https://leetcode.com/problems/single-number/) | [C](./src/136.c)|Easy| |141|[Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/) | [C](./src/141.c)|Easy| +|142|[Linked List Cycle II](https://leetcode.com/problems/linked-list-cycle-ii/) | [C](./src/142.c)|Medium| +|153|[Find Minimum in Rotated Sorted Array](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/) | [C](./src/153.c)|Medium| +|160|[Intersection of Two Linked Lists](https://leetcode.com/problems/intersection-of-two-linked-lists/) | [C](./src/160.c)|Easy| |169|[Majority Element](https://leetcode.com/problems/majority-element/) | [C](./src/169.c)|Easy| +|203|[Remove Linked List Elements](https://leetcode.com/problems/remove-linked-list-elements/) | [C](./src/203.c)|Easy| |206|[Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/) | [C](./src/206.c)|Easy| |215|[Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array/) | [C](./src/215.c)|Medium| |217|[Contains Duplicate](https://leetcode.com/problems/contains-duplicate/) | [C](./src/217.c)|Easy| |226|[Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree/) | [C](./src/226.c)|Easy| |234|[Palindrome Linked List](https://leetcode.com/problems/palindrome-linked-list/) | [C](./src/234.c)|Easy| |268|[Missing Number](https://leetcode.com/problems/missing-number/) | [C](./src/268.c)|Easy| +|278|[First Bad Version](https://leetcode.com/problems/first-bad-version/) | [C](./src/278.c)|Easy| +|283|[Move Zeroes](https://leetcode.com/problems/move-zeroes/) | [C](./src/283.c)|Easy| |287|[Find the Duplicate Number](https://leetcode.com/problems/find-the-duplicate-number/) | [C](./src/287.c)|Medium| |344|[Reverse String](https://leetcode.com/problems/reverse-string/) | [C](./src/344.c)|Easy| |387|[First Unique Character in a String](https://leetcode.com/problems/first-unique-character-in-a-string/) | [C](./src/387.c)|Easy| |389|[Find the Difference](https://leetcode.com/problems/find-the-difference/) | [C](./src/389.c)|Easy| |404|[Sum of Left Leaves](https://leetcode.com/problems/sum-of-left-leaves/) | [C](./src/404.c)|Easy| |442|[Find All Duplicates in an Array](https://leetcode.com/problems/find-all-duplicates-in-an-array/) | [C](./src/442.c)|Medium| +|509|[Fibonacci Number](https://leetcode.com/problems/fibonacci-number/) | [C](./src/509.c)|Easy| |520|[Detect Capital](https://leetcode.com/problems/detect-capital/) | [C](./src/520.c)|Easy| |561|[Array Partition I](https://leetcode.com/problems/array-partition-i/) | [C](./src/561.c)|Easy| |617|[Merge Two Binary Trees](https://leetcode.com/problems/merge-two-binary-trees/) | [C](./src/617.c)|Easy| +|674|[Longest Continuous Increasing Subsequence](https://leetcode.com/problems/longest-continuous-increasing-subsequence/) | [C](./src/674.c)|Easy| |700|[Search in a Binary Search Tree](https://leetcode.com/problems/search-in-a-binary-search-tree/) | [C](./src/700.c)|Easy| |701|[Insert into a Binary Search Tree](https://leetcode.com/problems/insert-into-a-binary-search-tree/) | [C](./src/701.c)|Medium| |704|[Binary Search](https://leetcode.com/problems/binary-search/) | [C](./src/704.c)|Easy| |709|[To Lower Case](https://leetcode.com/problems/to-lower-case/) | [C](./src/709.c)|Easy| |771|[Jewels and Stones](https://leetcode.com/problems/jewels-and-stones/) | [C](./src/771.c)|Easy| +|852|[Peak Index in a Mountain Array](https://leetcode.com/problems/peak-index-in-a-mountain-array/) | [C](./src/852.c)|Easy| |876|[Middle of the Linked List](https://leetcode.com/problems/middle-of-the-linked-list/) | [C](./src/876.c)|Easy| |905|[Sort Array By Parity](https://leetcode.com/problems/sort-array-by-parity/) | [C](./src/905.c)|Easy| |917|[Reverse Only Letters](https://leetcode.com/problems/reverse-only-letters/) | [C](./src/917.c)|Easy| |938|[Range Sum of BST](https://leetcode.com/problems/range-sum-of-bst/) | [C](./src/938.c)|Easy| |965|[Univalued Binary Tree](https://leetcode.com/problems/univalued-binary-tree/) | [C](./src/965.c)|Easy| +|977|[Squares of a Sorted Array](https://leetcode.com/problems/squares-of-a-sorted-array/) | [C](./src/977.c)|Easy| diff --git a/leetcode/src/109.c b/leetcode/src/109.c new file mode 100644 index 00000000..caaf34c4 --- /dev/null +++ b/leetcode/src/109.c @@ -0,0 +1,21 @@ +struct TreeNode* buildBST(struct ListNode* head, struct ListNode* tail) { + if(head == tail) + return NULL; + struct ListNode* slow = head, *fast = head; + while(fast != tail && fast->next != tail) { + fast = fast->next->next; + slow = slow->next; + } + struct TreeNode* node = malloc(sizeof(struct TreeNode)); + node->val = slow->val; + node->left = buildBST(head, slow); + node->right = buildBST(slow->next, tail); + return node; +} +struct TreeNode* sortedListToBST(struct ListNode* head){ + if (!head) + return NULL; + else + return buildBST(head, NULL); +} + diff --git a/leetcode/src/112.c b/leetcode/src/112.c new file mode 100644 index 00000000..d71bea45 --- /dev/null +++ b/leetcode/src/112.c @@ -0,0 +1,7 @@ +bool hasPathSum(struct TreeNode* root, int sum) { + if (root == NULL) + return 0; + if (!root->left && !root->right && sum - root->val == 0) + return 1; + return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val); +} diff --git a/leetcode/src/142.c b/leetcode/src/142.c new file mode 100644 index 00000000..46805d06 --- /dev/null +++ b/leetcode/src/142.c @@ -0,0 +1,19 @@ +struct ListNode *detectCycle(struct ListNode *head) { + if (head == NULL || head->next == NULL) + return NULL; + struct ListNode *slow, *fast; + slow = fast = head; + while(fast && fast->next) { + slow = slow->next; + fast = fast->next->next; + if(slow == fast) { + struct ListNode *entry = head; + while(slow != entry) { + slow = slow -> next; + entry = entry -> next; + } + return entry; + } + } + return NULL; +} diff --git a/leetcode/src/153.c b/leetcode/src/153.c new file mode 100644 index 00000000..2a86a4b5 --- /dev/null +++ b/leetcode/src/153.c @@ -0,0 +1,13 @@ +int findMin(int* nums, int numsSize){ + int low = 0, high = numsSize - 1; + while (low < high) { + int mid = low + (high - low) / 2; + /* minimum is on left side */ + if (nums[mid] < nums[high]) + high = mid; + /* minimum is on right side */ + else + low = mid + 1; + } + return nums[low]; +} diff --git a/leetcode/src/160.c b/leetcode/src/160.c new file mode 100644 index 00000000..fccd21ec --- /dev/null +++ b/leetcode/src/160.c @@ -0,0 +1,17 @@ +struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) { + struct ListNode *cur1 = headA, *cur2 = headB; + if(cur1 == NULL || cur2 == NULL) + return NULL; + while (cur1 && cur2 && cur1 != cur2) { + cur1 = cur1 -> next; + cur2 = cur2 -> next; + if (cur1 == cur2) + return cur1; + if(!cur1) + cur1 = headB; + if(!cur2) + cur2 = headA; + } + return cur1; + +} diff --git a/leetcode/src/203.c b/leetcode/src/203.c new file mode 100644 index 00000000..5ae6588f --- /dev/null +++ b/leetcode/src/203.c @@ -0,0 +1,10 @@ +struct ListNode* removeElements(struct ListNode* head, int val){ + if (head == NULL) + return NULL; + if(head->val == val) { + return removeElements(head->next, val); + } else { + head -> next = removeElements(head->next, val); + } + return head; +} diff --git a/leetcode/src/24.c b/leetcode/src/24.c new file mode 100644 index 00000000..9ae79813 --- /dev/null +++ b/leetcode/src/24.c @@ -0,0 +1,9 @@ +struct ListNode* swapPairs(struct ListNode* head) { + if(!head || !head->next) + return head; + struct ListNode *tmp = head->next; + head->next = swapPairs(head->next->next); + tmp -> next = head; + return tmp; + +} diff --git a/leetcode/src/27.c b/leetcode/src/27.c new file mode 100644 index 00000000..25f32762 --- /dev/null +++ b/leetcode/src/27.c @@ -0,0 +1,8 @@ +int removeElement(int* nums, int numsSize, int val) { + int i, start = 0; + for (i = 0; i < numsSize; i++) { + if(nums[i] != val) + nums[start++] = nums[i]; + } + return start; +} diff --git a/leetcode/src/278.c b/leetcode/src/278.c new file mode 100644 index 00000000..b08d7694 --- /dev/null +++ b/leetcode/src/278.c @@ -0,0 +1,15 @@ +// Forward declaration of isBadVersion API. +bool isBadVersion(int version); + +int firstBadVersion(int n) { + int low = 1, high = n; + while (low <= high) { + int mid = low + (high - low) / 2; + if(isBadVersion(mid)) { + high = mid - 1; + } else { + low = mid + 1; + } + } + return low; +} diff --git a/leetcode/src/283.c b/leetcode/src/283.c new file mode 100644 index 00000000..9eebe6a9 --- /dev/null +++ b/leetcode/src/283.c @@ -0,0 +1,10 @@ +void moveZeroes(int* nums, int numsSize){ + int i, start = 0; + for (i = 0; i < numsSize; i++) { + if(nums[i]) + nums[start++] = nums[i]; + } + for(;start < numsSize; start++) { + nums[start] = 0; + } +} diff --git a/leetcode/src/509.c b/leetcode/src/509.c new file mode 100644 index 00000000..5afd1d1c --- /dev/null +++ b/leetcode/src/509.c @@ -0,0 +1,7 @@ +int fib(int N){ + if(N == 0) + return 0; + if(N == 1) + return 1; + return fib(N - 1) + fib(N - 2); +} diff --git a/leetcode/src/53.c b/leetcode/src/53.c new file mode 100644 index 00000000..92547169 --- /dev/null +++ b/leetcode/src/53.c @@ -0,0 +1,13 @@ + +int maxcmp(int a, int b) { + return a >= b ? a : b; +} + +int maxSubArray(int* nums, int numsSize){ + int maxSoFar = nums[0], maxEndingHere = nums[0]; + for(int i = 1; i < numsSize; i++) { + maxEndingHere = maxcmp(maxEndingHere + nums[i], nums[i]); + maxSoFar = maxcmp(maxSoFar, maxEndingHere); + } + return maxSoFar; +} diff --git a/leetcode/src/674.c b/leetcode/src/674.c new file mode 100644 index 00000000..9f486d03 --- /dev/null +++ b/leetcode/src/674.c @@ -0,0 +1,16 @@ +int findLengthOfLCIS(int* nums, int numsSize){ + int maxval = 1, i, count = 1; + if (numsSize == 0) + return 0; + for (i = 1; i < numsSize; i++) { + if(nums[i] > nums[i -1]) { + count++; + if (count >= maxval) + maxval = count; + } else { + count = 1; + } + } + return maxval; +} + diff --git a/leetcode/src/82.c b/leetcode/src/82.c new file mode 100644 index 00000000..12a7ead6 --- /dev/null +++ b/leetcode/src/82.c @@ -0,0 +1,13 @@ +struct ListNode* deleteDuplicates(struct ListNode* head) { + if(head == NULL) + return NULL; + if(head->next && head->val == head->next->val) { + /* Remove all duplicate numbers */ + while(head->next && head->val == head->next->val) + head = head -> next; + return deleteDuplicates(head->next); + } else { + head->next = deleteDuplicates(head->next); + } + return head; +} diff --git a/leetcode/src/83.c b/leetcode/src/83.c new file mode 100644 index 00000000..3411c296 --- /dev/null +++ b/leetcode/src/83.c @@ -0,0 +1,11 @@ + +struct ListNode* deleteDuplicates(struct ListNode* head) { + struct ListNode* cur = head; + while (cur && cur->next) { + if(cur->val == cur->next->val) + cur->next = cur->next->next; + else + cur = cur->next; + } + return head; +} diff --git a/leetcode/src/852.c b/leetcode/src/852.c new file mode 100644 index 00000000..d658c9d2 --- /dev/null +++ b/leetcode/src/852.c @@ -0,0 +1,13 @@ +int peakIndexInMountainArray(int* A, int ASize) { + int low = 1, high = ASize; + while (low <= high) { + int mid = low + (high - low) / 2; + if (A[mid - 1] < A[mid] && A[mid] > A[mid + 1]) + return mid; + else if(A[mid - 1] < A[mid] && A[mid] < A[mid + 1]) + low = mid + 1; + else + high = mid - 1; + } + return -1; +} diff --git a/leetcode/src/94.c b/leetcode/src/94.c new file mode 100644 index 00000000..4a44a676 --- /dev/null +++ b/leetcode/src/94.c @@ -0,0 +1,15 @@ +void processTraversal(struct TreeNode *root, int *res, int *size) { + if(!root) + return; + processTraversal(root->left, res, size); + res[*size] = root->val; + *size = *size + 1; + processTraversal(root->right, res, size); +} + +int* inorderTraversal(struct TreeNode* root, int* returnSize){ + int *res = malloc(256*sizeof(int)); + *returnSize = 0; + processTraversal(root, res, returnSize); + return res; +} diff --git a/leetcode/src/977.c b/leetcode/src/977.c new file mode 100644 index 00000000..c0663504 --- /dev/null +++ b/leetcode/src/977.c @@ -0,0 +1,29 @@ +/* 1st way: Using 2 pointer */ +int* sortedSquares(int* A, int ASize, int* returnSize){ + int i, start = 0, end = ASize - 1; + int *res = malloc(ASize * sizeof(int)); + *returnSize = ASize; + for (i = ASize - 1; i >= 0; i--) { + if(abs(A[start]) > A[end]) { + res[i] = A[start] * A[start]; + start++; + } else { + res[i] = A[end] * A[end]; + end--; + } + } + return res; +} + +/* 2nd way: Using qsort */ +int cmpval(const void *a, const void *b) { + return *(int *)a - *(int *)b; +} +int* sortedSquares(int* A, int ASize, int* returnSize){ + int *res = malloc(ASize * sizeof(int)); + for (int i = 0; i < ASize; i++) + res[i] = A[i] * A[i]; + *returnSize = ASize; + qsort(res, ASize, sizeof(int), cmpval); + return res; +}