Add C++ implementation

begeekmyfriend · begeekmyfriend · commit 2be5ee97a17a · 2021-01-28T11:32:23.000+08:00
Signed-off-by: begeekmyfriend &lt;begeekmyfriend@gmail.com&gt;
diff --git a/0015_three_sum/three_sum.c b/0015_three_sum/three_sum.c
@@ -1,6 +1,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+
 static int compare(const void *a, const void *b)
 {
     return *(int *) a - *(int *) b;
@@ -30,7 +31,7 @@ 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)
+int** threeSum(int* nums, int numsSize, int* returnSize)
 {
     if (numsSize < 3) {
         return NULL;
diff --git a/0018_four_sum/four_sum.c b/0018_four_sum/four_sum.c
@@ -2,13 +2,14 @@
 #include <stdlib.h>
 #include <string.h>
 
+
 static int compare(const void *a, const void *b)
 {
     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, int *columnSizes)
+                  int *stack, int len, int **results, int *count, int *col_sizes)
 {
     int i;
     if (k == 2) {
@@ -23,7 +24,7 @@ static void k_sum(int *nums, int low, int high, int target, int total, int k,
                 stack[len++] = nums[high];
                 results[*count] = malloc(total * sizeof(int));
                 memcpy(results[*count], stack, total * sizeof(int));
-                columnSizes[*count] = total;
+                col_sizes[*count] = total;
                 (*count)++;
                 len -= 2;
                 while (++low < high && nums[low] == nums[low - 1]) {}
@@ -34,19 +35,19 @@ static void k_sum(int *nums, int low, int high, int target, int total, int k,
         /* k > 2 */
         for (i = low; i <= high - k + 1; i++) {
             if (i > low && nums[i] == nums[i - 1]) continue;
-            stack[len++] = nums[i];
-            k_sum(nums, i + 1, high, target - nums[i], 4, k - 1, stack, len,  results, count, columnSizes);
-            len--;
+            stack[len] = nums[i];
+            k_sum(nums, i + 1, high, target - nums[i], 4, k - 1, stack, len + 1, results, count, col_sizes);
         }
     }
 }
 
 /**
  * Return an array of arrays of size *returnSize.
  * The sizes of the arrays are returned as *returnColumnSizes array.
- * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ * Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  */
-int** fourSum(int* nums, int numsSize, int target, int* returnSize, int** returnColumnSizes) {
+int** fourSum(int* nums, int numsSize, int target, int* returnSize, int** returnColumnSizes)
+{
     *returnSize = 0;
     int i, j, capacity = 50000;
     int **results = malloc(capacity * sizeof(int *));
@@ -62,11 +63,11 @@ int** fourSum(int* nums, int numsSize, int target, int* returnSize, int** return
 
 int main(void)
 {
-    int i, count;
+    int i, count, target = 11, *col_sizes;
     //int nums[] = { 1, 0, -1, 0, -2, 2 };
     //int nums[] = { -3, -2, -1, 0, 0, 1, 2, 3 };
     int nums[] = { 0, 1, 5, 0, 1, 5, 5, -4 };
-    int **quadruplets = fourSum(nums, sizeof(nums) / sizeof(*nums), 11, &count);
+    int **quadruplets = fourSum(nums, sizeof(nums) / sizeof(*nums), target, &count, &col_sizes);
     for (i = 0; i < count; i++) {
         printf("%d %d %d %d\n", quadruplets[i][0], quadruplets[i][1], quadruplets[i][2], quadruplets[i][3]);
     }
diff --git a/0039_combination_sum/combination_sum.c b/0039_combination_sum/combination_sum.c
@@ -28,10 +28,10 @@ static void dfs(int *nums, int size, int start, int target, int *stack,
  ** The sizes of the arrays are returned as *returnColumnSizes array.
  ** Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  **/
-static int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int **returnColumnSizes)
+int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int **returnColumnSizes)
 {
     int cap = 200;
-    int *stack = malloc(candidatesSize * sizeof(int));
+    int *stack = malloc(cap * sizeof(int));
     int **results = malloc(cap * sizeof(int *));
     *returnColumnSizes = malloc(cap * sizeof(int));
     *returnSize = 0;
diff --git a/0040_combination_sum_ii/combination_sum.c b/0040_combination_sum_ii/combination_sum.c
@@ -11,15 +11,15 @@ static int compare(const void *a, const void *b)
 }
 
 static void dfs(int *nums, int size, int start, int target, int *solution,
-                int len, int **results, int *count, int *column_sizes)
+                int len, int **results, int *count, int *col_sizes)
 {
     int i;
     if (target < 0) {
         return;
     } else if (target == 0) {
         results[*count] = malloc(len * sizeof(int));
         memcpy(results[*count], solution, len * sizeof(int));
-        column_sizes[*count] = len;
+        col_sizes[*count] = len;
         (*count)++;
     } else {
         int last = INT_MIN;
@@ -28,7 +28,7 @@ static void dfs(int *nums, int size, int start, int target, int *solution,
                 /* No duplicate combinations in the same level position */
                 solution[len] = nums[i];
                 /* i + 1 limits the candidate range in next levels */
-                dfs(nums, size, i + 1, target - nums[i], solution, len + 1, results, count, column_sizes);
+                dfs(nums, size, i + 1, target - nums[i], solution, len + 1, results, count, col_sizes);
             }
             last = nums[i];
         }
@@ -40,7 +40,7 @@ static void dfs(int *nums, int size, int start, int target, int *solution,
  ** The sizes of the arrays are returned as *returnColumnSizes array.
  ** Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  **/
-static int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes)
+int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes)
 {
     qsort(candidates, candidatesSize, sizeof(int), compare);
 
diff --git a/0046_permutations/permutations.c b/0046_permutations/permutations.c
@@ -58,9 +58,9 @@ static void dfs(int *nums, int size, bool *used, int *stack,
 /**
  * Return an array of arrays of size *returnSize.
  * The sizes of the arrays are returned as *returnColumnSizes array.
- * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ * Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  */
-static int** permute(int* nums, int numsSize, int* returnSize, int** returnColumnSizes)
+int** permute(int* nums, int numsSize, int* returnSize, int** returnColumnSizes)
 {
     int count = 0, cap = 5000;
     int **results = malloc(cap * sizeof(int *));
diff --git a/0049_group_anagrams/anagrams.c b/0049_group_anagrams/anagrams.c
@@ -29,7 +29,7 @@ static inline int BKDRHash(char *s, size_t size)
  ** The sizes of the arrays are returned as *returnColumnSizes array.
  ** Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  **/
-static char*** groupAnagrams(char** strs, int strsSize, int* returnSize, int** returnColumnSizes)
+char*** groupAnagrams(char** strs, int strsSize, int* returnSize, int** returnColumnSizes)
 {
     int i, j, count = 0;
     int hash_size = strsSize;
@@ -72,10 +72,10 @@ static char*** groupAnagrams(char** strs, int strsSize, int* returnSize, int** r
 
 int main(int argc, char **argv)
 {
-    int *column_sizes, count = 0, i, j;
-    char ***lists = groupAnagrams(argv + 1, argc - 1, &count, &column_sizes);
+    int *col_sizes, count = 0, i, j;
+    char ***lists = groupAnagrams(argv + 1, argc - 1, &count, &col_sizes);
     for (i = 0; i < count; i++) {
-        for (j = 0; j < column_sizes[i]; j++) {
+        for (j = 0; j < col_sizes[i]; j++) {
             printf("%s ", lists[i][j]);
         }
         printf("\n");
diff --git a/0049_group_anagrams/anagrams.cc b/0049_group_anagrams/anagrams.cc
@@ -9,14 +9,14 @@ class Solution {
         unordered_map<string, vector<string>> ht;
         for (const auto& str : strs) {
             int counts[26] = { 0 };
-            for (const auto& s : str) {
-                counts[s - 'a']++;
+            for (char c : str) {
+                counts[c - 'a']++;
             }
 
             string key;
-            for (const auto& c : counts) {
+            for (int i : counts) {
                 key.push_back('#');
-                key.push_back(c + '0');
+                key.push_back(i + '0');
             }
 
             ht[key].push_back(str);
diff --git a/0051_n_queens/n_queens.c b/0051_n_queens/n_queens.c
@@ -73,7 +73,7 @@ static void dfs(int n, int row, int *stack, char ***solutions, int *count, int *
 /**
  * Return an array of arrays of size *returnSize.
  * The sizes of the arrays are returned as *returnColumnSizes array.
- * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ * Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  */
 char *** solveNQueens(int n, int* returnSize, int** returnColumnSizes)
 {
diff --git a/0056_merge_intervals/merge_intervals.c b/0056_merge_intervals/merge_intervals.c
@@ -11,7 +11,7 @@ static int compare(const void *a, const void *b)
 /**
  * Return an array of arrays of size *returnSize.
  * The sizes of the arrays are returned as *returnColumnSizes array.
- * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ * Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  */
 int** merge(int** intervals, int intervalsSize, int* intervalsColSize, int* returnSize, int** returnColumnSizes)
 {
diff --git a/0057_insert_interval/insert_interval.c b/0057_insert_interval/insert_interval.c
@@ -10,9 +10,10 @@ static int compare(const void *a, const void *b)
 /**
  * Return an array of arrays of size *returnSize.
  * The sizes of the arrays are returned as *returnColumnSizes array.
- * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ * Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  */
-int** insert(int** intervals, int intervalsSize, int* intervalsColSize, int* newInterval, int newIntervalSize, int* returnSize, int** returnColumnSizes)
+int** insert(int** intervals, int intervalsSize, int* intervalsColSize, int* newInterval,
+             int newIntervalSize, int* returnSize, int** returnColumnSizes)
 {
     int i, len = 0;
     int *tmp = malloc((intervalsSize + 1) * 2 * sizeof(int));
diff --git a/0059_spiral_matrix_ii/spiral_matrix.c b/0059_spiral_matrix_ii/spiral_matrix.c
@@ -5,7 +5,7 @@
 /**
  * Return an array of arrays of size *returnSize.
  * The sizes of the arrays are returned as *returnColumnSizes array.
- * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ * Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  */
 int** generateMatrix(int n, int* returnSize, int** returnColumnSizes)
 {
diff --git a/0077_combinations/combinations.c b/0077_combinations/combinations.c
@@ -3,6 +3,7 @@
 #include <stdbool.h>
 #include <string.h>
 
+
 static void dfs(int n, int k, int start, int *stack, int len,
                 int **results, int *count, int *col_sizes)
 {
@@ -23,7 +24,7 @@ static void dfs(int n, int k, int start, int *stack, int len,
 /**
  * Return an array of arrays of size *returnSize.
  * The sizes of the arrays are returned as *returnColumnSizes array.
- * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ * Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  */
 int** combine(int n, int k, int* returnSize, int** returnColumnSizes) {
     int capacity = 10000;
diff --git a/0078_subsets/subsets.c b/0078_subsets/subsets.c
@@ -2,33 +2,34 @@
 #include <stdlib.h>
 #include <string.h>
 
-static void dfs(int *nums, int size, int start, int *buf,
+
+static void dfs(int *nums, int size, int start, int *stack,
                 int len, int **sets, int *count, int *sizes)
 {
     int i;
     sets[*count] = malloc(len * sizeof(int));
-    memcpy(sets[*count], buf, len * sizeof(int));
+    memcpy(sets[*count], stack, len * sizeof(int));
     sizes[*count] = len;
     (*count)++;
     for (i = start; i < size; i++) {
-        buf[len] = nums[i];
-        dfs(nums, size, i + 1, buf, len + 1, sets, count, sizes);
+        stack[len] = nums[i];
+        dfs(nums, size, i + 1, stack, len + 1, sets, count, sizes);
     }
 }
 
 /**
  ** Return an array of arrays of size *returnSize.
  ** The sizes of the arrays are returned as *returnColumnSizes array.
- ** Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ ** Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  **/
 int** subsets(int* nums, int numsSize, int* returnSize, int** returnColumnSizes)
 {
     int capacity = 5000;
     int **sets = malloc(capacity * sizeof(int *));
-    int *buf = malloc(numsSize * sizeof(int));
+    int *stack = malloc(numsSize * sizeof(int));
     *returnColumnSizes = malloc(capacity * sizeof(int));
     *returnSize = 0;
-    dfs(nums, numsSize, 0, buf, 0, sets, returnSize, *returnColumnSizes);
+    dfs(nums, numsSize, 0, stack, 0, sets, returnSize, *returnColumnSizes);
     return sets;
 }
 
diff --git a/0107_binary_tree_level_order_traversal_ii/bst_bfs.c b/0107_binary_tree_level_order_traversal_ii/bst_bfs.c
@@ -2,7 +2,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define BST_MAX_LEVEL 800
 
 struct TreeNode {
     int val;
@@ -29,9 +28,9 @@ static void bfs(struct TreeNode *root, int **results, int *count, int *col_sizes
 /**
  ** Return an array of arrays of size *returnSize.
  ** The sizes of the arrays are returned as *returnColumnSizes array.
- ** Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ ** Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  **/
-static int** levelOrderBottom(struct TreeNode* root, int* returnSize, int** returnColumnSizes)
+int** levelOrderBottom(struct TreeNode* root, int* returnSize, int** returnColumnSizes)
 {
     if (root == NULL) {
         *returnSize = 0;
@@ -40,9 +39,9 @@ static int** levelOrderBottom(struct TreeNode* root, int* returnSize, int** retu
 
     int size = 1;
     *returnSize = 0;
-    int **results = malloc(BST_MAX_LEVEL * sizeof(int *));
-    *returnColumnSizes = malloc(BST_MAX_LEVEL * sizeof(int));
-    memset(*returnColumnSizes, 0, BST_MAX_LEVEL * sizeof(int));
+    int **results = malloc(800 * sizeof(int *));
+    *returnColumnSizes = malloc(800 * sizeof(int));
+    memset(*returnColumnSizes, 0, 800 * sizeof(int));
     bfs(root, results, returnSize, *returnColumnSizes, &size, 0);
 
     int i, j;
diff --git a/0113_path_sum_ii/path_sum.c b/0113_path_sum_ii/path_sum.c
@@ -2,6 +2,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+
 struct TreeNode {
     int val;
     struct TreeNode *left;
@@ -25,7 +26,12 @@ static void dfs(struct TreeNode *node, int sum, int *stack, int len, int **resul
     }
 }
 
-static int **pathSum(struct TreeNode *root, int sum, int **columnSizes, int *returnSize)
+/**
+ * Return an array of arrays of size *returnSize.
+ * The sizes of the arrays are returned as *returnColumnSizes array.
+ * Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
+ */
+int **pathSum(struct TreeNode *root, int sum, int *returnSize, int **returnColumnSizes)
 {
     if (root == NULL) {
         *returnSize = 0;
@@ -35,8 +41,8 @@ static int **pathSum(struct TreeNode *root, int sum, int **columnSizes, int *ret
     int level = 5000, cap = 1000;
     int *stack = malloc(level * sizeof(int));
     int **results = malloc(cap * sizeof(int *));
-    *columnSizes = malloc(cap * sizeof(int));
-    dfs(root, sum, stack, 0, results, *columnSizes, returnSize);
+    *returnColumnSizes = malloc(cap * sizeof(int));
+    dfs(root, sum, stack, 0, results, *returnColumnSizes, returnSize);
     return results;
 }
 
@@ -76,13 +82,14 @@ int main(int argc, char **argv)
     n3[7].right = NULL;
 
     int i, j, count = 0;
-    int *sizes;
-    int **list = pathSum(&root, 22, &sizes, &count);
+    int *col_sizes, sum = 22;
+    int **list = pathSum(&root, sum, &count, &col_sizes);
     for (i = 0; i < count; i++) {
-        for (j = 0; j < sizes[i]; j++) {
+        for (j = 0; j < col_sizes[i]; j++) {
             printf("%d ", list[i][j]);
         }
         printf("\n");
     }
+
     return 0;
 }
diff --git a/0118_pascal_triangle/pascal_triangle.c b/0118_pascal_triangle/pascal_triangle.c
diff --git a/0131_palindrome_patitioning/palindrome_partition.c b/0131_palindrome_patitioning/palindrome_partition.c

Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ static void dfs(int n, int row, int stack, char *solutions, int count, int *`
`73`	`73`	`/**`
`74`	`74`	`* Return an array of arrays of size *returnSize.`
`75`	`75`	`* The sizes of the arrays are returned as *returnColumnSizes array.`
`76`		`- * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().`
	`76`	`+ * Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().`
`77`	`77`	`*/`
`78`	`78`	`char *** solveNQueens(int n, int* returnSize, int** returnColumnSizes)`
`79`	`79`	`{`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ static int compare(const void a, const void b)`
`11`	`11`	`/**`
`12`	`12`	`* Return an array of arrays of size *returnSize.`
`13`	`13`	`* The sizes of the arrays are returned as *returnColumnSizes array.`
`14`		`- * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().`
	`14`	`+ * Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().`
`15`	`15`	`*/`
`16`	`16`	`int merge(int intervals, int intervalsSize, int* intervalsColSize, int* returnSize, int** returnColumnSizes)`
`17`	`17`	`{`