improving tree_traversal.c

Author: Gathros

chapters/tree_traversal/code/c/tree_traversal.c

@@ -1,101 +1,59 @@
-#include <stdio.h>
+#include "utility.h"
+
+#include <stddef.h>
 #include <stdlib.h>
-#include <string.h>
+#include <stdio.h>
 
-typedef struct node {
+struct node {
     struct node *children;
-    int children_num;
+    size_t children_size;
     int id;
-} node;
-
-typedef struct node_list {
-    node n;
-    struct node_list *last_list, *next_list;
-} node_list;
-
-typedef struct node_points {
-    node_list *start_point, *end_point;
-} node_points;
-
-void push(node_points *np, node n) {
-    node_list *temp = (node_list*)malloc(sizeof(node_list));
-    temp->n = n;
-    temp->last_list = temp->next_list = NULL;
-
-    if (!np->end_point) {
-        np->start_point = temp;
-    } else {
-        np->end_point->next_list = temp;
-        temp->last_list = np->end_point;
-    }
-
-    np->end_point = temp;
-}
+};
 
-void stack_pop(node_points *np) {
-    node_list *temp;
-    temp = np->end_point;
+struct node create_tree(int rows, size_t num_children) {
+    struct node n = {NULL, 0, rows};
 
-    if (temp) {
-        np->end_point = temp->last_list;
-        if (!np->end_point) {
-            np->start_point = NULL;
+    if (rows > 0) {
+        n.children = (struct node*)malloc(num_children * sizeof(struct node));
+        n.children_size = num_children;
+        for (size_t i = 0; i < num_children; ++i) {
+            n.children[i] = create_tree(rows - 1, num_children);
         }
-
-        free(temp);
     }
-}
-
-void queue_pop(node_points *np) {
-    node_list *temp;
-    temp = np->start_point;
-    if (temp) {
-        np->start_point = temp->next_list;
-        if (!np->start_point) {
-            np->end_point = NULL;
-        }
 
-        free(temp);
-    }
+    return n;
 }
 
-void create_tree(node *n, int num_row, int num_child) {
-    n->id = num_row;
-    if (num_row == 0) {
-        n->children_num = 0;
-        return;
-    }
+void destroy_tree(struct node n) {
+    if (n.id > 0) {
+        for (size_t i = 0; i < n.children_size; ++i) {
+            destroy_tree(n.children[i]);
+        }
 
-    n->children = (node *)malloc(num_child * sizeof(*n->children));
-    n->children_num = num_child;
-    for (int i = 0; i < num_child; ++i) {
-        node child;
-        create_tree(&child, num_row - 1, num_child);
-        *(n->children + i) = child;
+        free(n.children);
     }
 }
 
-void dfs_recursive(node n) {
+void dfs_recursive(struct node n) {
     printf("%d\n", n.id);
-    if (!n.children) {
-        return;
-    }
 
-    for (int i = 0; i < n.children_num; ++i) {
-        dfs_recursive(n.children[i]);
+    if (n.children) {
+        for (size_t i = 0; i < n.children_size; ++i) {
+            dfs_recursive(n.children[i]);
+        }
     }
 }
 
-void dfs_recursive_postorder(node n) {
-    for (int i = 0; i < n.children_num; ++i) {
+void dfs_recursive_postorder(struct node n) {
+    for (size_t i = 0; i < n.children_size; ++i) {
         dfs_recursive_postorder(n.children[i]);
     }
 
     printf("%d\n", n.id);
 }
 
-void dfs_recursive_inorder_btree(node n) {
-    switch (n.children_num) {
+void dfs_recursive_inorder_btree(struct node n) {
+    switch (n.children_size) {
     case 2:
         dfs_recursive_inorder_btree(n.children[0]);
         printf("%d\n", n.id);
@@ -114,65 +72,50 @@ void dfs_recursive_inorder_btree(node n) {
     }
 }
 
-void dfs_stack(node n) {
-    node_points stack;
-    memset(&stack, 0, sizeof(node_points));
-    push(&stack, n);
-    node temp;
-
-    while (stack.start_point != NULL) {
-        temp = stack.end_point->n;
-        printf("%d\n", temp.id);
-        stack_pop(&stack);
-        for (int i = 0; i < temp.children_num; ++i) {
-            if (!temp.children) {
-                break;
-            }
-
-            push(&stack, temp.children[i]);
+void dfs_stack(struct node n) {
+    struct stack stk = get_stack(sizeof(struct node*));
+    stack_push(&stk, &n);
+    struct node *tmp;
+
+    while (!stack_empty(&stk)) {
+        tmp = (struct node*)stack_pop(&stk);
+        if (!tmp) {
+            break;
         }
-    }
-}
 
-void bfs_queue(node n) {
-    node_points queue;
-    memset(&queue, 0, sizeof(node_points));
-    push(&queue, n);
-    node temp;
-
-    while (queue.start_point != NULL) {
-        temp = queue.start_point->n;
-        printf("%d\n", temp.id);
-        queue_pop(&queue);
-        for (int i = 0; i < temp.children_num; ++i) {
-            if (!temp.children) {
-                break;
-            }
-
-            push(&queue, temp.children[i]);
+        printf("%d\n", tmp->id);
+        for (size_t i = 0; i < tmp->children_size; ++i) {
+            stack_push(&stk, &tmp->children[i]);
         }
     }
+
+    free_stack(stk);
 }
 
-void destroy_tree(node *n) {
-    if (n->id == 0) {
-        return;
-    }
+void bfs_queue(struct node n) {
+    struct queue q = get_queue(sizeof(struct node*));
+    enqueue(&q, &n);
+    struct node *tmp;
 
-    for (int i = 0; i < n->children_num; ++i) {
-        destroy_tree(n->children + i);
+    while (!queue_empty(&q)) {
+        tmp = (struct node*)dequeue(&q);
+        if (!tmp) {
+            break;
+        }
+
+        printf("%d\n", tmp->id);
+        for (size_t i = 0; i < tmp->children_size; ++i) {
+            enqueue(&q, &tmp->children[i]);
+        }
     }
 
-    free(n->children);
+    free_queue(q);
 }
 
 int main() {
-    node root;
-    create_tree(&root, 3, 3);
-    dfs_recursive(root);
-    //dfs_stack(root);
-    //bfs_queue(root);
-    destroy_tree(&root);
+    struct node root = create_tree(3, 3);
+    bfs_queue(root);
+    destroy_tree(root);
 
     return 0;
 }

chapters/tree_traversal/code/c/utility.h

@@ -0,0 +1,105 @@
+#ifndef UTILITY_H
+#define UTILITY_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct stack {
+    void **data;
+    size_t top, capacity, size;
+};
+
+struct queue {
+    void **data;
+    size_t front, back, capacity;
+};
+
+struct stack get_stack(size_t size) {
+    struct stack stk;
+
+    stk.data = malloc(4 * size);
+    stk.capacity = 4;
+    stk.top = 0;
+
+    return stk;
+}
+
+bool stack_empty(struct stack *stk) {
+    return stk->top == 0;
+}
+
+void stack_push(struct stack *stk, void *element) {
+    if (stk->top == stk->capacity) {
+        stk->capacity *= 2;
+        stk->data = realloc(stk->data, stk->capacity * sizeof(stk->data[0]));
+    }
+
+    stk->data[stk->top++] = element;
+}
+
+void *stack_pop(struct stack *stk) {
+    if (stack_empty(stk)) {
+        return NULL;
+    }
+
+    return stk->data[--stk->top];
+}
+
+void free_stack(struct stack stk) {
+    free(stk.data);
+}
+
+struct queue get_queue(size_t size) {
+    struct queue q;
+
+    q.data = calloc(4, size);
+    q.front = 0;
+    q.back = 0;
+    q.capacity = 4;
+
+    return q;
+}
+
+bool queue_empty(struct queue *q) {
+    return q->front == q->back;
+}
+
+void queue_resize(struct queue *q) {
+    size_t size = sizeof(q->data[0]);
+    void **tmp = calloc((q->capacity * 2), size);
+    memcpy(tmp, q->data + q->front, (q->capacity - q->front) * size);
+    memcpy(tmp + q->capacity - q->front, q->data, (q->front - 1) * size);
+
+    q->data = tmp;
+    q->back = q->capacity - 1;
+    q->front = 0;
+    q->capacity *= 2;
+}
+
+void enqueue(struct queue *q, void *element) {
+    if (q->front == (q->back % q->capacity) + 1) {
+        queue_resize(q);
+    }
+
+    q->data[q->back] = element;
+    q->back = (q->back + 1) % q->capacity;
+}
+
+void *dequeue(struct queue *q) {
+    if (queue_empty(q)) {
+        return NULL;
+    }
+
+    void *ret = q->data[q->front];
+    q->front = (q->front + 1) % q->capacity;
+
+    return ret;
+}
+
+void free_queue(struct queue q) {
+    free(q.data);
+}
+
+#endif //UTILITY_H