Refine

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

Author: begeekmyfriend

102_binary_tree_level_order_traversal/bst_bfs.c

@@ -4,154 +4,46 @@
 
 #define BST_MAX_LEVEL 800
 
-#define container_of(ptr, type, member) \
-    ((type *)((char *)(ptr) - (size_t)&(((type *)0)->member)))
-
-#define list_entry(ptr, type, member) \
-    container_of(ptr, type, member)
-
-#define	list_first_entry(ptr, type, field)  list_entry((ptr)->next, type, field)
-#define	list_last_entry(ptr, type, field)  list_entry((ptr)->prev, type, field)
-
-#define	list_for_each(p, head) \
-	for (p = (head)->next; p != (head); p = p->next)
-
-#define	list_for_each_safe(p, n, head) \
-	for (p = (head)->next, n = p->next; p != (head); p = n, n = p->next)
-
 struct TreeNode {
     int val;
     struct TreeNode *left;
     struct TreeNode *right;
 };
 
-struct list_head {
-    struct list_head *next, *prev;
-};
-
-static inline void INIT_LIST_HEAD(struct list_head *list)
-{
-    list->next = list->prev = list;
-}
-
-static inline int list_empty(const struct list_head *head)
-{
-    return (head->next == head);
-}
-
-static inline void __list_add(struct list_head *new, struct list_head *prev, struct list_head *next)
-{
-    next->prev = new;
-    new->next = next;
-    new->prev = prev;
-    prev->next = new;
-}
-
-static inline void list_add(struct list_head *_new, struct list_head *head)
-{
-    __list_add(_new, head, head->next);
-}
-
-static inline void list_add_tail(struct list_head *_new, struct list_head *head)
-{
-    __list_add(_new, head->prev, head);
-}
-
-static inline void __list_del(struct list_head *entry)
+static void bfs(struct TreeNode *root, int **results, int *count, int *col_sizes, int *size, int level)
 {
-    entry->next->prev = entry->prev;
-    entry->prev->next = entry->next;
-}
-
-static inline void list_del(struct list_head *entry)
-{
-    __list_del(entry);
-    entry->next = entry->prev = NULL;
-}
-
-struct bfs_node {
-    struct TreeNode *node;
-    struct list_head link;
-};
-
-static struct bfs_node *node_new(struct list_head *free_list, struct TreeNode *node)
-{
-    struct bfs_node *new;
-    if (list_empty(free_list)) {
-        new = malloc(sizeof(*new));
-    } else {
-        new = list_first_entry(free_list, struct bfs_node, link);
-        list_del(&new->link);
-    }
-    new->node = node;
-    return new;
-}
-
-static void queue(struct list_head *parents, struct list_head *children,
-                  struct list_head *free_list, int **results, int *col_sizes, int level)
-{
-    struct list_head *p, *n;
-    list_for_each(p, parents) {
-        struct bfs_node *new;
-        struct bfs_node *parent = list_entry(p, struct bfs_node, link);
-        if (parent->node->left != NULL) {
-            new = node_new(free_list, parent->node->left);
-            list_add_tail(&new->link, children);
-        }
-        if (parent->node->right != NULL) {
-            new = node_new(free_list, parent->node->right);
-            list_add_tail(&new->link, children);
-        }
-        col_sizes[level]++;
+    if (root == NULL) {
+        return;
     }
 
-    int i = 0;
-    results[level] = malloc(col_sizes[level] * sizeof(int));
-    list_for_each_safe(p, n, parents) {
-        struct bfs_node *parent = list_entry(p, struct bfs_node, link);
-        results[level][i++] = parent->node->val;
-        list_del(p);
-        list_add(p, free_list);
+    *count = level + 1 > *count ? level + 1 : *count;
+    if (col_sizes[level] == 0) {
+        *size = *size > 256 ? 256 : *size * 2;
+        results[level] = malloc(*size * sizeof(int));
     }
+    results[level][col_sizes[level]++] = root->val;
+    bfs(root->left, results, count, col_sizes, size, level + 1);
+    bfs(root->right, results, count, col_sizes, size, level + 1);
 }
 
 /**
  ** Return an array of arrays of size *returnSize.
- ** The sizes of the arrays are returned as *columnSizes array.
+ ** The sizes of the arrays are returned as *returnColumnSizes array.
  ** Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
  **/
-static int** levelOrder(struct TreeNode* root, int** columnSizes, int* returnSize)
+static int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes)
 {
     if (root == NULL) {
         *returnSize = 0;
         return NULL;
     }
 
-    struct list_head free_list;
-    struct list_head q0;
-    struct list_head q1;
-    INIT_LIST_HEAD(&free_list);
-    INIT_LIST_HEAD(&q0);
-    INIT_LIST_HEAD(&q1);
-
+    int size = 1;
+    *returnSize = 0;
     int **results = malloc(BST_MAX_LEVEL * sizeof(int *));
-    *columnSizes = malloc(BST_MAX_LEVEL * sizeof(int));
-    memset(*columnSizes, 0, BST_MAX_LEVEL * sizeof(int));
-
-    int level = 0;
-    struct bfs_node *new = node_new(&free_list, root);
-    list_add_tail(&new->link, &q0);
-
-    while (!list_empty(&q0) || !list_empty(&q1)) {
-        if (level & 0x1) {
-            queue(&q1, &q0, &free_list, results, *columnSizes, level);
-        } else {
-            queue(&q0, &q1, &free_list, results, *columnSizes, level);
-        }
-        level++;
-    }
-
-    *returnSize = level;
+    *returnColumnSizes = malloc(BST_MAX_LEVEL * sizeof(int));
+    memset(*returnColumnSizes, 0, BST_MAX_LEVEL * sizeof(int));
+    bfs(root, results, returnSize, *returnColumnSizes, &size, 0);
     return results;
 }
 
@@ -186,7 +78,7 @@ int main(void)
     node2[3].right = NULL;
 
     int i, j, count = 0, *col_sizes;
-    int **lists = levelOrder(&root, &col_sizes, &count);
+    int **lists = levelOrder(&root, &count, &col_sizes);
     for (i = 0; i < count; i++) {
         for (j = 0; j < col_sizes[i]; j++) {
             printf("%d ", lists[i][j]);

103_binary_tree_zigzag_level_order_traversal/bst_zigzag.c

@@ -133,10 +133,10 @@ static void queue(struct list_head *parents, struct list_head *children, int rev
 
 /**
  ** Return an array of arrays of size *returnSize.
- ** The sizes of the arrays are returned as *columnSizes array.
+ ** The sizes of the arrays are returned as *returnColumnSizes array.
  ** Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
  **/
-static int** zigzagLevelOrder(struct TreeNode* root, int** columnSizes, int* returnSize)
+static int** zigzagLevelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes)
 {
     if (root == NULL) {
         *returnSize = 0;
@@ -151,18 +151,18 @@ static int** zigzagLevelOrder(struct TreeNode* root, int** columnSizes, int* ret
     INIT_LIST_HEAD(&q1);
 
     int **results = malloc(BST_MAX_LEVEL * sizeof(int *));
-    *columnSizes = malloc(BST_MAX_LEVEL * sizeof(int));
-    memset(*columnSizes, 0, BST_MAX_LEVEL * sizeof(int));
+    *returnColumnSizes = malloc(BST_MAX_LEVEL * sizeof(int));
+    memset(*returnColumnSizes, 0, BST_MAX_LEVEL * sizeof(int));
 
     int level = 0;
     struct bfs_node *new = node_new(&free_list, root);
     list_add_tail(&new->link, &q0);
 
     while (!list_empty(&q0) || !list_empty(&q1)) {
         if (level & 0x1) {
-            queue(&q1, &q0, 1, &free_list, results, *columnSizes, level);
+            queue(&q1, &q0, 1, &free_list, results, *returnColumnSizes, level);
         } else {
-            queue(&q0, &q1, 0, &free_list, results, *columnSizes, level);
+            queue(&q0, &q1, 0, &free_list, results, *returnColumnSizes, level);
         }
         level++;
     }
@@ -223,7 +223,7 @@ int main(void)
     node2[3].right = NULL;
 
     int i, j, count = 0, *col_sizes;
-    int **lists = zigzagLevelOrder(&root, &col_sizes, &count);
+    int **lists = zigzagLevelOrder(&root, &count, &col_sizes);
     for (i = 0; i < count; i++) {
         for (j = 0; j < col_sizes[i]; j++) {
             printf("%d ", lists[i][j]);