Improve

Signed-off-by: begeekmyfriend <[email protected]>

Author: begeekmyfriend

001_two_sum/two_sum.c

@@ -1,48 +1,39 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-static void bubble_sort(int *nums, int *indexes, int size)
+struct object {
+    int val;
+    int index;
+};
+
+static int compare(const void *a, const void *b)
 {
-    int i, flag = size;
-    while (flag > 0) {
-        int len = flag;
-        flag = 0;
-        for (i = 1; i < len; i++) {
-            if (nums[i] < nums[i - 1]) {
-                int tmp = nums[i];
-                nums[i] = nums[i - 1];
-                nums[i - 1] = tmp;
-                tmp = indexes[i];
-                indexes[i] = indexes[i - 1];
-                indexes[i - 1] = tmp;
-                flag = i;
-            }
-        }
-    }
+    return ((struct object *) a)->val - ((struct object *) b)->val;
 }
 
 static int * twosum(int *nums, int numsSize, int target)
 {
     int i, j;
-    int *indexes = malloc(numsSize * sizeof(int));
+    struct object *objs = malloc(numsSize * sizeof(*objs));
     for (i = 0; i < numsSize; i++) {
-        indexes[i] = i;
+        objs[i].val = nums[i];
+        objs[i].index = i;
     }
-    bubble_sort(nums, indexes, numsSize);
+    qsort(objs, numsSize, sizeof(*objs), compare);
 
     int count = 0;
     int *results = malloc(2 * sizeof(int));
     i = 0;
     j = numsSize - 1;
     while (i < j) {
-        int diff = target - nums[i];
-        if (diff > nums[j]) {
-            while (++i < j && nums[i] == nums[i - 1]) {}
-        } else if (diff < nums[j]) {
-            while (--j > i && nums[j] == nums[j + 1]) {}
+        int diff = target - objs[i].val;
+        if (diff > objs[j].val) {
+            while (++i < j && objs[i].val == objs[i - 1].val) {}
+        } else if (diff < objs[j].val) {
+            while (--j > i && objs[j].val == objs[j + 1].val) {}
         } else {
-            results[0] = indexes[i];
-            results[1] = indexes[j];
+            results[0] = objs[i].index;
+            results[1] = objs[j].index;
             return results;
         }
     }

003_longest_substring_without_repeat/longest_substring_without_repeat.c

@@ -2,32 +2,40 @@
 #include <stdlib.h>
 #include <string.h>
 
-static int lengthOfLongestSubstring(char *s) {
+static int lengthOfLongestSubstring(char *s)
+{
     int offset[128];
     int max_len = 0;
-    char *p, *q;
     int len = 0;
+    int index = 0;
+
     memset(offset, 0xff, sizeof(offset));
-    for (p = s; *p != '\0'; p++) {
-        for (q = p; *q != '\0'; q++) {
-            if (offset[*q] == -1) {
-                offset[*q] = q - s;
-                if (++len > max_len) {
-                    max_len = len;
-                }
+    while (*s != '\0') {
+        if (offset[*s] == -1) {
+            len++;
+        } else {
+            if (index - offset[*s] > len) {
+                len++;
             } else {
-	        len = 0;
-                p = offset[*q] + s;
-                memset(offset, 0xff, sizeof(offset));
-                break;
+	        len = index - offset[*s];
             }
         }
+        if (len > max_len) {
+            max_len = len;
+        }
+        offset[*s++] = index++;
     }
+
     return max_len;
 }
 
 int main(int argc, char **argv)
 {
+    if (argc != 2) {
+        fprintf(stderr, "Usage: ./test string\n");
+        exit(-1);
+    }
+
     printf("%d\n", lengthOfLongestSubstring(argv[1]));
     return 0;
 }

004_median_of_two_sorted_array/median_of_two_sorted_array.c

@@ -1,32 +1,37 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-static double find_kth(int a[], int m, int b[], int n, int k)  
+static double find_kth(int a[], int alen, int b[], int blen, int k)  
 {  
-    /* Always assume that m is equal or smaller than n */ 
-    if (m > n) {
-        return find_kth(b, n, a, m, k);
+    /* Always assume that alen is equal or smaller than blen */ 
+    if (alen > blen) {
+        return find_kth(b, blen, a, alen, k);
     }
-    if (m == 0) {
+
+    if (alen == 0) {
         return b[k - 1];
     }
+
     if (k == 1) {
         return a[0] < b[0] ? a[0] : b[0];
     }
 
     /* Divide k into two parts */
-    int i = k / 2 < m ? k / 2 : m;
-    int j = k - i;  
-    if (a[i - 1] < b[j - 1]) {
-        return find_kth(a + i, m - i, b, n, k - i);
-    } else if (a[i - 1] > b[j - 1]) {  
-        return find_kth(a, m, b + j, n - j, k - j);
+    int ia = k / 2 < alen ? k / 2 : alen;
+    int ib = k - ia;  
+    if (a[ia - 1] < b[ib - 1]) {
+        /* a[ia - 1] must be ahead of k-th */
+        return find_kth(a + ia, alen - ia, b, blen, k - ia);
+    } else if (a[ia - 1] > b[ib - 1]) {  
+        /* b[ib - 1] must be ahead of k-th */
+        return find_kth(a, alen, b + ib, blen - ib, k - ib);
     } else {
-        return a[i - 1];
+        return a[ia - 1];
     }
 }
 
-double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size) {
+static double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size)
+{
     int half = (nums1Size + nums2Size) / 2;
     if ((nums1Size + nums2Size) & 0x1) {
         return find_kth(nums1, nums1Size, nums2, nums2Size, half + 1);

014_longest_common_prefix/common_prefix.c

@@ -4,22 +4,17 @@
 
 static char* longestCommonPrefix(char** strs, int strsSize)
 {
-    int i, capacity = 50, count = 0;
-    char *result = malloc(50);
-    bool go_on = true;
-    while (strsSize > 0 && go_on) {
-        char temp = strs[0][count];
+    int i, count = 0;
+    char *result = malloc(100);
+    while (strsSize > 0) {
+        char c = strs[0][count];
         for (i = 1; i < strsSize; i++) {
-            if (temp != strs[i][count]) break;
+            if (c != strs[i][count]) break;
         }
-        if (i == strsSize && temp != '\0') {
-            if (count + 1 + 1 >= capacity) {
-                capacity *= 2;
-                result = realloc(result, capacity + 1);
-            }
-            result[count++] = temp;
+        if (i == strsSize && c != '\0') {
+            result[count++] = c;
         } else {
-            go_on = false;
+            break;
         }
     }
     result[count++] = '\0';

015_three_sum/three_sum.c

@@ -1,16 +1,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-static void insert_sort(int *nums, int len)
+static int compare(const void *a, const void *b)
 {
-    int i, j;
-    for (i = 1; i < len; i++) {
-        int tmp = nums[i];
-        for (j = i - 1; j >= 0 && nums[j] > tmp; j--) {
-            nums[j + 1] = nums[j];
-        }
-        nums[j + 1] = tmp;
-    }
+    return *(int *) a - *(int *) b;
 }
 
 static void two_sum(int *nums, int low, int high, int target, int **results, int *count)
@@ -37,20 +30,22 @@ static void two_sum(int *nums, int low, int high, int target, int **results, int
  ** Return an array of arrays of size *returnSize.
  ** Note: The returned array must be malloced, assume caller calls free().
  **/
-static int** threeSum(int* nums, int numsSize, int* returnSize) {
+static int** threeSum(int* nums, int numsSize, int* returnSize)
+{
     if (numsSize < 3) {
         return NULL;
     }
-    insert_sort(nums, numsSize);
 
-    int i, j, count = 0, capacity = 50000;
+    qsort(nums, numsSize, sizeof(*nums), compare);
+
+    *returnSize = 0;
+    int i, j, capacity = 50000;
     int **results = malloc(capacity * sizeof(int *));
     for (i = 0; i < numsSize; i++) {
         if (i == 0 || i > 0 && nums[i] != nums[i - 1]) {
-            two_sum(nums, i + 1, numsSize - 1, -nums[i], results, &count);
+            two_sum(nums, i + 1, numsSize - 1, -nums[i], results, returnSize);
         }
     }
-    *returnSize = count;
     return results;
 }
 

016_three_sum_closest/three_sum_closest.c

@@ -3,26 +3,20 @@
 #include <math.h>
 #include <limits.h>
 
-static void insert_sort(int *a, int size)
+static int compare(const void *a, const void *b)
 {
-    int i, j;
-    for (i = 1; i < size; i++) {
-        int tmp = a[i];
-        for (j = i - 1; j >= 0 && a[j] > tmp; j--) {
-            a[j + 1] = a[j];
-        }
-        a[j + 1] = tmp;
-    }
+    return *(int *) a - *(int *) b;
 }
 
-static int threeSumClosest(int* nums, int numsSize, int target) {
+static int threeSumClosest(int* nums, int numsSize, int target)
+{
     int i, min_diff = INT_MAX;
 
     if (numsSize < 3) {
         return min_diff;
     }
 
-    insert_sort(nums, numsSize);
+    qsort(nums, numsSize, sizeof(*nums), compare);
 
     for (i = 0; i < numsSize - 2; i++) {
         int left = i + 1;
@@ -37,7 +31,7 @@ static int threeSumClosest(int* nums, int numsSize, int target) {
             } else if (diff > 0) {
                 right--;
             } else {
-                break;
+                return target;
             }
         }
     }

018_four_sum/four_sum.c

@@ -2,20 +2,13 @@
 #include <stdlib.h>
 #include <string.h>
 
-static void insert_sort(int *nums, int len)
+static int compare(const void *a, const void *b)
 {
-    int i, j;
-    for (i = 1; i < len; i++) {
-        int tmp = nums[i];
-        for (j = i - 1; j >= 0 && nums[j] > tmp; j--) {
-            nums[j + 1] = nums[j];
-        }
-        nums[j + 1] = tmp;
-    }
+    return *(int *) a - *(int *) b;
 }
 
-static void k_sum(int *nums, int low, int high, int target, int total, int k,
-                  int *stack, int len, int **results, int *count)
+static void k_sum(int *nums, int low, int high, int target, int total,
+                  int k, int *stack, int len, int **results, int *count)
 {
     int i;
     if (k == 2) {
@@ -51,16 +44,19 @@ static void k_sum(int *nums, int low, int high, int target, int total, int k,
  ** Return an array of arrays of size *returnSize.
  ** Note: The returned array must be malloced, assume caller calls free().
  **/
-static int** fourSum(int* nums, int numsSize, int target, int* returnSize) {
+static int** fourSum(int* nums, int numsSize, int target, int* returnSize)
+{
     if (numsSize < 4) {
         return NULL;
     }
-    insert_sort(nums, numsSize);
-    int i, j, count = 0, capacity = 50000;
+
+    qsort(nums, numsSize, sizeof(*nums), compare);
+
+    *returnSize = 0;
+    int i, j, capacity = 50000;
     int **results = malloc(capacity * sizeof(int *));
     int *stack = malloc(4 * sizeof(int));
-    k_sum(nums, 0, numsSize - 1, target, 4, 4, stack, 0, results, &count);
-    *returnSize = count;
+    k_sum(nums, 0, numsSize - 1, target, 4, 4, stack, 0, results, returnSize);
     return results;
 }
 

019_remove_nth_node_from_end_of_list/remove_end.c

@@ -1,15 +1,16 @@
 #include <stdio.h>
 #include <stdlib.h>
 
- struct ListNode {
-     int val;
-     struct ListNode *next;
- };
+struct ListNode {
+    int val;
+    struct ListNode *next;
+};
 
-struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
-    struct ListNode *p, *prev, dummy;
+static struct ListNode* removeNthFromEnd(struct ListNode* head, int n)
+{
     if (n < 1) return NULL;
 
+    struct ListNode *p, *prev, dummy;
     dummy.next = head;
     p = prev = &dummy;
     while (n-- > 0) {
@@ -26,7 +27,6 @@ struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
     if (tmp == head) {
         head = tmp->next;
     }
-    free(tmp);
     return head;
 }
 

022_generate_paratheses/parentheses.c

@@ -6,8 +6,9 @@
  ** Return an array of size *returnSize.
  ** Note: The returned array must be malloced, assume caller calls free().
  **/
-char** generateParenthesis(int n, int* returnSize) {
-    int left, right, cap = 1, count = 0;
+static char** generateParenthesis(int n, int* returnSize)
+{
+    int left, right, cap = 5000, count = 0;
     char *stack = malloc(2 * n + 1);
     char **parentheses = malloc(cap * sizeof(char *));
 
@@ -18,11 +19,6 @@ char** generateParenthesis(int n, int* returnSize) {
     /* begin and end condition of loop */
     while (p != stack || count == 0) {
         if (left == n && right == n) {
-            /* new stacks */
-            if (count + 1 >= cap) {
-                cap *= 2;
-                parentheses = realloc(parentheses, cap * sizeof(char *));
-            }
             parentheses[count] = malloc(2 * n + 1);
             strcpy(parentheses[count], stack);
             count++;