Merge pull request #337 from CertifiedBlyndGuy/master

leetcode: Address readability of a few cases, and fix 283

leetcode/src/1189.c

@@ -10,15 +10,15 @@ int maxNumberOfBalloons(char * text){
     int i, min_counter_ballons;
     
     for (char *ptr = text; *ptr; ptr++) {
-        if(*ptr == 'b') {
+        if (*ptr == 'b') {
             count_letters[0]++;
-        }else if(*ptr == 'a') {
+        } else if(*ptr == 'a') {
             count_letters[1]++;
-        }else if(*ptr == 'l') {
+        } else if (*ptr == 'l') {
             count_letters[2]++;
-        }else if(*ptr == 'o') {
+        } else if(*ptr == 'o') {
             count_letters[3]++;
-        }else if(*ptr == 'n') {
+        } else if(*ptr == 'n') {
             count_letters[4]++;
         }
     }
@@ -29,10 +29,10 @@ int maxNumberOfBalloons(char * text){
     
     /* Max number of times which we can write ballon is equal to min value of letters on count_letter */
     min_counter_ballons = count_letters[0];
-    for(i = 1; i < 5; i++){
+    for (i = 1; i < 5; i++) {
-        if(count_letters[i] < min_counter_ballons)
+        if (count_letters[i] < min_counter_ballons)
             min_counter_ballons = count_letters[i];
     }
     
     return min_counter_ballons;
-}
+}

leetcode/src/283.c

@@ -1,10 +1,12 @@
-void moveZeroes(int* nums, int numsSize){
+void moveZeroes(int* nums, int numsSize) {
-    int i, start = 0;
+    int i = 0, start = 0;
+
     for (i = 0; i < numsSize; i++) {
-        if(nums[i])
+        if (nums[i])
             nums[start++] = nums[i];
     }
-    for(;start < numsSize; start++) {
+
+    for (start; start < numsSize; start++) {
         nums[start] = 0;
     }
 }

leetcode/src/617.c

@@ -6,7 +6,7 @@ struct TreeNode * newNode (int item) {
 }
 
 struct TreeNode* mergeTrees(struct TreeNode* t1, struct TreeNode* t2){
-    if(t1 == NULL && t2 == NULL)
+    if (t1 == NULL && t2 == NULL)
         return NULL;
     int item = (t1 == NULL ? 0 : t1->val) + (t2 == NULL ? 0 : t2->val);
     struct TreeNode *node = newNode(item);

leetcode/src/700.c

@@ -11,10 +11,12 @@
 struct TreeNode* searchBST(struct TreeNode* root, int val){
     if(!root)
         return NULL;
-    if(root->val == val)
+
+    if (root->val == val) {
         return root;
-    else if (root->val > val)
+    } else if (root->val > val) {
         return searchBST(root->left, val);
-    else
+    } else {
         return searchBST(root->right, val);
+    }
 }

leetcode/src/704.c

@@ -2,12 +2,13 @@ int search(int* nums, int numsSize, int target){
     int low = 0, high = numsSize - 1;
     while (low <= high) {
         int mid = low + (high - low) / 2;
-        if (target > nums[mid])
+        if (target > nums[mid]) {
             low = mid + 1;
-        else if (target < nums[mid])
+        } else if (target < nums[mid]) {
             high = mid - 1;
-        else
+        } else {
             return mid;
+        }
     }
     return -1;
 }

leetcode/src/771.c

@@ -1,18 +1,18 @@
-// for strlen( )
+// for strlen()
-#include<string.h>
+#include <string.h>
 
-int numJewelsInStones(char * j, char * s){
+int numJewelsInStones(char * j, char * s) {
-	// as strlen is O(n), store it once rather than using it in for loop
+    // as strlen is O(n), store it once rather than using it in for loop
-    int cnt[500],lens=strlen(s),lenj=strlen(j),sol=0;
+    int cnt[500], lens = strlen(s), lenj = strlen(j), sol = 0;
-    memset(cnt,0,sizeof(cnt));
+    memset(cnt, 0, sizeof(cnt));
 
     // lookup to know which character occurs in j
-    for(int i=0;i<lenj;i++)
+    for (int i = 0; i < lenj; i++)
         cnt[j[i]]++;
 
     // count the characters in s
-    for(int i=0;i<lens;i++)
+    for (int i = 0; i < lens; i++)
-        sol+=cnt[s[i]];
+        sol += cnt[s[i]];
 
     return sol;
 }

leetcode/src/82.c

@@ -1,10 +1,12 @@
 struct ListNode* deleteDuplicates(struct ListNode* head) {
-    if(head == NULL)
+    if (head == NULL)
         return NULL;
-    if(head->next && head->val == head->next->val) {
+
+    if (head->next && head->val == head->next->val) {
         /* Remove all duplicate numbers */
-        while(head->next && head->val == head->next->val)
+        while (head->next && head->val == head->next->val) {
             head = head -> next;
+        }
         return deleteDuplicates(head->next);
     } else {
         head->next = deleteDuplicates(head->next);

leetcode/src/905.c

@@ -10,13 +10,13 @@
  *
  * Note: The returned array must be malloced, assume caller calls free().
  */
-int* sortArrayByParity(int* A, int ASize, int* returnSize){
+int* sortArrayByParity(int* A, int ASize, int* returnSize) {
     int *retArr = malloc(ASize * sizeof(int));
     int oddIndex = ASize - 1;
     int evenIndex = 0;
     *returnSize = ASize;
     for (int i = 0; i < ASize; i++) {
-        if(A[i] % 2 == 0) {
+        if (A[i] % 2 == 0) {
             retArr[evenIndex] = A[i];
             evenIndex++;
         } else {

leetcode/src/938.c

@@ -1,9 +1,9 @@
 int rangeSumBST(struct TreeNode* root, int L, int R){
-    if (root == NULL)
+    if (root == NULL) {
         return 0;
-    else if (root->val >= L && root->val <= R)
+    } else if (root->val >= L && root->val <= R) {
         return root->val + rangeSumBST(root->left, L, R) + rangeSumBST(root->right, L, R);
-    else
+    } else {
         return rangeSumBST(root->left, L, R) + rangeSumBST(root->right, L, R);
-
+    }
 }

leetcode/src/977.c

@@ -1,10 +1,10 @@
-/* 1st way: Using 2 pointer */
+/* 1st way: Using 2 pointers */
 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]) {
+        if (abs(A[start]) > A[end]) {
             res[i] = A[start] * A[start];
             start++;
         } else {
@@ -19,7 +19,8 @@ int* sortedSquares(int* A, int ASize, int* returnSize){
 int cmpval(const void *a, const void *b) {
     return *(int *)a - *(int *)b;
 }
-int* sortedSquares(int* A, int ASize, int* returnSize){
+
+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];