Annotation

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

Author: begeekmyfriend

041_first_missing_positive/missing_positive.c

@@ -16,7 +16,9 @@ static int firstMissingPositive(int* nums, int numsSize)
 
     int i = 0;
     while (i < numsSize) {
-        if (nums[i] != i + 1 && nums[i] > 0 && nums[i] <= numsSize && nums[i] != nums[nums[i] - 1]) {
+        /* nums[i] should be i+1 and nums[nums[i] - 1] should be nums[i] */
+        if (nums[i] != i + 1 && nums[i] > 0 && nums[i] <= numsSize && nums[nums[i] - 1] != nums[i]) {
+            /* nums[nums[i] - 1] <- nums[i] */
             swap(nums + i, nums + nums[i] - 1);
         } else {
             i++;

045_jump_game_ii/jump_game.c

@@ -12,7 +12,9 @@ static int jump(int* nums, int numsSize)
     int steps = 0;
     while (hi < numsSize - 1) {
         int right = 0;
+        /* [lo, hi] is the next location range, find the farest jump */
         for (i = lo; i <= hi; i++) {
+            /* Assume right > hi for the purpose of the problem */
             right = max(i + nums[i], right);
         }
         lo = hi + 1;

055_jump_game/jump_game.c

@@ -14,6 +14,7 @@ static bool canJump(int* nums, int numsSize)
         if (pos < i || pos >= numsSize - 1) {
             break;
         }
+        /* if all positive number it always can arrive. */
         pos = max(i + nums[i], pos);
     }
 

075_sort_colors/sort_colors.c

@@ -9,49 +9,38 @@ static inline void swap(int *a, int *b)
     *b = tmp;
 }
 
-/*
- * RED = 0
- * WHITE = 1
- * BLUE = 2
- */
 static void sortColors(int* nums, int numsSize)
 {
-    int i = 0, j = numsSize - 1;
-    while (i < j) {
-        while (nums[i] == 0 && i < j) {
-            i++;
+    int i, j = 0;
+    for (i = 0; i < numsSize; i++) {
+        if (nums[i] == 0) {
+            swap(nums + j, nums + i);
+            j++;
         }
-        while (nums[j] != 0 && j > i) {
-            j--;
-        }
-        swap(nums + i, nums + j);
     }
-    j = numsSize - 1;
-    while (i < j) {
-        while (nums[i] == 1 && i < j) {
-            i++;
-        }
-        while (nums[j] != 1 && j > i) {
-            j--;
+
+    for (i = j; i < numsSize; i++) { 
+        if (nums[i] == 1) {
+            swap(nums + j, nums + i);
+            j++;
         }
-        swap(nums + i, nums + j);
     }
 }
 
 int main(int argc, char **argv)
 {
-    if (argc != 2) {
-        fprintf(stderr, "Usage: ./test colors\n");
+    if (argc < 2) {
+        fprintf(stderr, "Usage: ./test 2 0 2 1 1 0\n");
         exit(-1);
     }
-    int i, count = strlen(argv[1]);
+    int i, count = argc - 1;
     int *nums = malloc(count * sizeof(int));
     for (i = 0; i < count; i++) {
-        nums[i] = argv[1][i] - '0';
+        nums[i] = atoi(argv[i + 1]);
     }
     sortColors(nums, count);
     for (i = 0; i < count; i++) {
-        printf("%d", nums[i]);
+        printf("%d ", nums[i]);
     }
     printf("\n");
     return 0;

080_remove_duplicates_from_sorted_array_ii/rm_dups.c

@@ -9,14 +9,17 @@ static int removeDuplicates(int* nums, int numsSize)
 
     int i;
     int len = 0;
-    int count = 0;
+    int count = 1;
     for (i = 1; i < numsSize; i++) {
+        /* Find the start position to be replaced */
         if (nums[len] == nums[i]) {
             if (count < 2) {
                 count++;
+                /* Replace in each iteration */
                 nums[++len] = nums[i];
             }
         } else {
+            /* Here there are more than 2 duplicates */
             count = 1;
             nums[++len] = nums[i];
         }

085_maximal_rectangle/maximal_rectangle.c

@@ -11,32 +11,32 @@ static inline int max(int a, int b)
 static int area_calc(int *heights, int size)
 {
     int *indexes = malloc(size * sizeof(int));
-    int *left = malloc(size * sizeof(int));
-    int *right = malloc(size * sizeof(int));
+    int *lhist = malloc(size * sizeof(int));
+    int *rhist = malloc(size * sizeof(int));
 
     int i, pos = 0;
     for (i = 0; i < size; i++) {
-        /* monotonous increasing stack */
+        /* squeeze to keep monotonous increasing histograms */
         while (pos > 0 && heights[indexes[pos - 1]] >= heights[i]) {
             pos--;
         }
-        left[i] = pos == 0 ? -1 : indexes[pos - 1];
+        lhist[i] = pos == 0 ? -1 : indexes[pos - 1];
         indexes[pos++] = i;
     }
 
     pos = 0;
     for (i = size - 1; i >= 0; i--) {
-        /* monotonous increasing stack */
+        /* squeeze to keep monotonous increasing histograms */
         while (pos > 0 && heights[indexes[pos - 1]] >= heights[i]) {
             pos--;
         }
-        right[i] = pos == 0 ? size : indexes[pos - 1];
+        rhist[i] = pos == 0 ? size : indexes[pos - 1];
         indexes[pos++] = i;
     }
 
     int max_area = 0;
     for (i = 0; i < size; i++) {
-        int area = heights[i] * (right[i] - left[i] - 1);
+        int area = heights[i] * (rhist[i] - lhist[i] - 1);
         max_area = max(area, max_area);
     }
 

086_partition_list/partition_list.c

@@ -6,29 +6,37 @@ struct ListNode {
     struct ListNode *next;
 };
 
-struct ListNode* partition(struct ListNode* head, int x) {
+struct ListNode* partition(struct ListNode* head, int x)
+{
     struct ListNode dummy;
-    struct ListNode *p = NULL, *start = &dummy, *pivot;    
+    struct ListNode *prev1 = &dummy, *pivot;    
+
     dummy.next = head;
     for (pivot = head; pivot != NULL; pivot = pivot->next) {
         if (pivot->val >= x) {
-            /* start->next == pivot */
             break;
         }
-        start = pivot;
+        prev1 = pivot;
     }
 
-    struct ListNode *prev;
-    for (p = pivot; p != NULL; p = p->next) {
+    struct ListNode *p = pivot->next;
+    struct ListNode *prev2 = pivot;
+    while (p != NULL) {
         if (p->val < x) {
-            prev->next = p->next;
-            p->next = start->next;
-            start->next = p;
-            start = p;
-            p = prev;
+            /* deletion */
+            prev2->next = p->next;
+            /* insertion */
+            p->next = prev1->next;
+            prev1->next = p;
+            /* iteration */
+            prev1 = p;
+            p = prev2->next;
+        } else {
+            prev2 = p;
+            p = p->next;
         }
-        prev = p;
     }
+
     return dummy.next;
 }
 

087_scramble_string/scramble_string.c

@@ -12,25 +12,21 @@
  *       or
  *          isScramble(s1[0..j], s2[n - j - 1, n]) &&  isScramble(s1[j+1..n], s2[0..n - j])
  */
-#define N 128
-
 static bool scramble(char *s1, int low1, int high1, char *s2, int low2, int high2)
 {
     if (high1 - low1 != high2 - low2) {
         return false;
     } else if (!memcmp(s1 + low1, s2 + low2, high1 - low1 + 1)) {
         return true;
     } else {
-        int i, c1[N], c2[N];
-        memset(c1, 0, N * sizeof(int));
-        memset(c2, 0, N * sizeof(int));
+        int i, c1[128] = { 0 }, c2[128] = { 0 };
         for (i = low1; i <= high1; i++) {
             c1[s1[i]]++;
         }
         for (i = low2; i <= high2; i++) {
             c2[s2[i]]++;
         }
-        if (memcmp(c1, c2, N * sizeof(int))) {
+        if (memcmp(c1, c2, 128 * sizeof(int))) {
             return false;
         } else {
             int len = high1 - low1 + 1;

094_binary_tree_inorder_traversal/bst_inorder_traversal.c

@@ -1,24 +1,22 @@
 #include <stdio.h>
 #include <stdlib.h>
 
- struct TreeNode {
-     int val;
-     struct TreeNode *left;
-     struct TreeNode *right;
- };
+struct TreeNode {
+    int val;
+    struct TreeNode *left;
+    struct TreeNode *right;
+};
 
 static void traverse(struct TreeNode *node, int *result, int *count)
 {
-    if (node->left != NULL) {
-        traverse(node->left, result, count);
+    if (node == NULL) {
+        return;
     }
-    
+
+    traverse(node->left, result, count);
     result[*count] = node->val;
     (*count)++;
-    
-    if (node->right != NULL) {
-        traverse(node->right, result, count);
-    }    
+    traverse(node->right, result, count);
 }
 
 /**

113_path_sum_ii/path_sum.c

@@ -12,20 +12,17 @@ static void dfs(struct TreeNode *node, int sum, int *stack, int len, int **resul
 {
     if (node == NULL) {
         return;
-    }
-
-    sum -= node->val;
-    if (node->left == NULL && node->right == NULL && sum == 0) {
+    } else if (node->left == NULL && node->right == NULL && sum == node->val) {
         results[*count] = malloc((len + 1) * sizeof(int));
         memcpy(results[*count], stack, len * sizeof(int));
         results[*count][len] = node->val;
         sizes[*count] = len + 1;
         (*count)++;
-        return;
+    } else {
+        stack[len] = node->val;
+        dfs(node->left, sum - node->val, stack, len + 1, results, sizes, count);
+        dfs(node->right, sum - node->val, stack, len + 1, results, sizes, count);
     }
-    stack[len] = node->val;
-    dfs(node->left, sum, stack, len + 1, results, sizes, count);
-    dfs(node->right, sum, stack, len + 1, results, sizes, count);
 }
 
 static int **pathSum(struct TreeNode *root, int sum, int **columnSizes, int *returnSize)