Refine

begeekmyfriend · begeekmyfriend · commit c9ba0251662f · 2020-09-09T00:00:41.000+08:00
Signed-off-by: begeekmyfriend &lt;begeekmyfriend@gmail.com&gt;
diff --git a/069_sqrt/sqrt.c b/069_sqrt/sqrt.c
@@ -25,8 +25,8 @@ static double mySqrt(double x)
 
 static double mySqrt(double n)
 {
-    /* Solute the zero point of f(x) = 0 => x ^ 2 - n = 0 */
-    /* f(x) = (x - x0)f'(x0) - f(x0) = 0 First order of Tylor series */
+    /* Solute the zero point of f(x). Let F(x) = f(x) - n = 0 */
+    /* then (x - x0)F'(x0) + F(x0) = 0 which is the first order of Tylor series */
     double x = 1.0;
     while (fabs(x * x - n) > 1e-8) {
         // x = x - (x * x - n) / (2 * x);
diff --git a/088_merge_sorted_array/merge_array.c b/088_merge_sorted_array/merge_array.c
@@ -1,21 +1,20 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+
 static void merge(int* nums1, int m, int* nums2, int n)
 {
     int i = m - 1, j = n - 1, k = nums1Size - 1;
-    while (i >= 0 && j >= 0 && k >= 0) {
+    while (i >= 0 && j >= 0) {
         if (nums1[i] >= nums2[j]) {
             nums1[k--] = nums1[i--];
         } else {
             nums1[k--] = nums2[j--];
         }
     }
 
-    if (i == -1) {
-        while (j >= 0) {
-            nums1[k--] = nums2[j--];
-        }
+    while (j >= 0) {
+        nums1[k--] = nums2[j--];
     }
 }
 
diff --git a/108_convert_sorted_array_to_binary_search_tree/bst_convert.c b/108_convert_sorted_array_to_binary_search_tree/bst_convert.c
@@ -10,19 +10,19 @@ struct TreeNode {
 
 static struct TreeNode *partition(int *nums, int lo, int hi)
 {
+    if (lo > hi) {
+        return NULL;
+    }
     int mid = lo + (hi - lo) / 2;
     struct TreeNode *node = malloc(sizeof(*node));
     node->val = nums[mid];
-    node->left = mid > lo ? partition(nums, lo, mid - 1) : NULL;
-    node->right = mid < hi ? partition(nums, mid + 1, hi) : NULL;
+    node->left = partition(nums, lo, mid - 1);
+    node->right = partition(nums, mid + 1, hi);
     return node;
 }
 
 static struct TreeNode* sortedArrayToBST(int* nums, int numsSize)
 {
-    if (numsSize == 0) {
-        return NULL;
-    }
     return partition(nums, 0, numsSize - 1);
 }
 
diff --git a/112_path_sum/path_sum.c b/112_path_sum/path_sum.c
@@ -2,6 +2,7 @@
 #include <stdlib.h>
 #include <stdbool.h>
 
+
 struct TreeNode {
     int val;
     struct TreeNode *left;
@@ -11,8 +12,10 @@ struct TreeNode {
 static bool hasPathSum(struct TreeNode *root, int sum)
 {
     if (root == NULL) {
+        /* Here is non leaf */
         return false;
     } else if (root->left == NULL && root->right == NULL && root->val == sum) {
+        /* Here must be leaf */
         return true;
     } else {
         return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);

Original file line number	Diff line number	Diff line change
`@@ -1,21 +1,20 @@`
`1`	`1`	`#include <stdio.h>`
`2`	`2`	`#include <stdlib.h>`
`3`	`3`
	`4`	`+`
`4`	`5`	`static void merge(int* nums1, int m, int* nums2, int n)`
`5`	`6`	`{`
`6`	`7`	`int i = m - 1, j = n - 1, k = nums1Size - 1;`
`7`		`- while (i >= 0 && j >= 0 && k >= 0) {`
	`8`	`+ while (i >= 0 && j >= 0) {`
`8`	`9`	`if (nums1[i] >= nums2[j]) {`
`9`	`10`	`nums1[k--] = nums1[i--];`
`10`	`11`	`} else {`
`11`	`12`	`nums1[k--] = nums2[j--];`
`12`	`13`	`}`
`13`	`14`	`}`
`14`	`15`
`15`		`- if (i == -1) {`
`16`		`- while (j >= 0) {`
`17`		`- nums1[k--] = nums2[j--];`
`18`		`- }`
	`16`	`+ while (j >= 0) {`
	`17`	`+ nums1[k--] = nums2[j--];`
`19`	`18`	`}`
`20`	`19`	`}`
`21`	`20`
Original file line number	Diff line number	Diff line change
`@@ -10,19 +10,19 @@ struct TreeNode {`
`10`	`10`
`11`	`11`	`static struct TreeNode partition(int nums, int lo, int hi)`
`12`	`12`	`{`
	`13`	`+ if (lo > hi) {`
	`14`	`+ return NULL;`
	`15`	`+ }`
`13`	`16`	`int mid = lo + (hi - lo) / 2;`
`14`	`17`	`struct TreeNode node = malloc(sizeof(node));`
`15`	`18`	`node->val = nums[mid];`
`16`		`- node->left = mid > lo ? partition(nums, lo, mid - 1) : NULL;`
`17`		`- node->right = mid < hi ? partition(nums, mid + 1, hi) : NULL;`
	`19`	`+ node->left = partition(nums, lo, mid - 1);`
	`20`	`+ node->right = partition(nums, mid + 1, hi);`
`18`	`21`	`return node;`
`19`	`22`	`}`
`20`	`23`
`21`	`24`	`static struct TreeNode* sortedArrayToBST(int* nums, int numsSize)`
`22`	`25`	`{`
`23`		`- if (numsSize == 0) {`
`24`		`- return NULL;`
`25`		`- }`
`26`	`26`	`return partition(nums, 0, numsSize - 1);`
`27`	`27`	`}`
`28`	`28`