Adding missing examples for Tree Traversal and FFT in C.

chapters/FFT/code/c/fft.c

@@ -1,10 +1,21 @@
 #include <complex.h>
 #include <math.h>
+#include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
-#include <stdio.h>
 
-#define PI 3.1415926535897932384626
+void dft(double complex *X, const size_t N) {
+    double complex tmp[N];
+    for (size_t i = 0; i < N; ++i) {
+        tmp[i] = 0;
+        for (size_t j = 0; j < N; ++j) {
+            tmp[i] += X[j] * cexp(-2.0 * M_PI * I * j * i / N);
+        }
+    }
+
+    memcpy(X, tmp, N * sizeof(*X));
+}
 
 void cooley_tukey(double complex *X, const size_t N) {
     if (N >= 2) {
@@ -21,38 +32,40 @@ void cooley_tukey(double complex *X, const size_t N) {
         cooley_tukey(X + N / 2, N / 2);
 
         for (size_t i = 0; i < N / 2; ++i) {
-            X[i + N / 2] = X[i] - cexp(-2.0 * I * PI * i / N) * X[i + N / 2];
+            X[i + N / 2] = X[i] - cexp(-2.0 * I * M_PI * i / N) * X[i + N / 2];
             X[i] -= (X[i + N / 2]-X[i]);
         }
     }
 }
 
 void bit_reverse(double complex *X, size_t N) {
-        double complex temp;
-        unsigned int b;
+    for (int i = 0; i < N; ++i) {
+        int n = i;
+        int a = i;
+        int count = (int)log2((double)N) - 1;
 
-        for (unsigned int i = 0; i < N; ++i) {
-                b = i;
-                b = (((b & 0xaaaaaaaa) >> 1) | ((b & 0x55555555) << 1));
-                b = (((b & 0xcccccccc) >> 2) | ((b & 0x33333333) << 2));
-                b = (((b & 0xf0f0f0f0) >> 4) | ((b & 0x0f0f0f0f) << 4));
-                b = (((b & 0xff00ff00) >> 8) | ((b & 0x00ff00ff) << 8));
-                b = ((b >> 16) | (b << 16)) >>
-                        (32 - (unsigned int) log2((double)N));
-                if (b > i) {
-                        temp = X[b];
-                        X[b] = X[i];
-                        X[i] = temp;
-                }
+        n >>= 1;
+        while (n > 0) {
+            a = (a << 1) | (n & 1);
+            count--;
+            n >>= 1;
         }
+        n = (a << count) & ((1 << (int)log2((double)N)) - 1);
+
+        if (n > i) {
+            double complex tmp = X[i];
+            X[i] = X[n];
+            X[n] = tmp;
+        }
+    }
 }
 
 void iterative_cooley_tukey(double complex *X, size_t N) {
     bit_reverse(X, N);
 
     for (int i = 1; i <= log2((double)N); ++i) {
         int stride = pow(2, i);
-        double complex w = cexp(-2.0 * I * PI / stride);
+        double complex w = cexp(-2.0 * I * M_PI / stride);
         for (size_t j = 0; j < N; j += stride) {
             double complex v = 1.0;
             for (size_t k = 0; k < stride / 2; ++k) {

chapters/FFT/cooley_tukey.md

@@ -72,7 +72,7 @@ For some reason, though, putting code to this transformation really helped me fi
 {% sample lang="jl" %}
 [import:2-11, lang:"julia"](code/julia/fft.jl)
 {% sample lang="c" %}
-[import:2-11, lang:"julia"](code/julia/fft.jl)
+[import:7-19, lang:"c_cpp"](code/c/fft.c)
 {% sample lang="cpp" %}
 [import:2-11, lang:"julia"](code/julia/fft.jl)
 {% sample lang="hs" %}
@@ -117,7 +117,7 @@ In the end, the code looks like:
 {% sample lang="jl" %}
 [import:14-31, lang:"julia"](code/julia/fft.jl)
 {% sample lang="c" %}
-[import:9-28, lang:"c_cpp"](code/c/fft.c)
+[import:21-40, lang:"c_cpp"](code/c/fft.c)
 {% sample lang="cpp" %}
 [import:27-57, lang:"c_cpp"](code/c++/fft.cpp)
 {% sample lang="hs" %}

chapters/tree_traversal/code/c/tree_traversal.c

@@ -1,150 +1,121 @@
-#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;
-    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;
+    size_t children_size;
+    int id;
+};
+
+struct node create_tree(int rows, size_t num_children) {
+    struct node n = {NULL, 0, rows};
+
+    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);
+        }
     }
 
-    np->end_point = temp;
+    return n;
 }
 
-void stack_pop(node_points *np) {
-    node_list *temp;
-    temp = np->end_point;
-
-    if (temp) {
-        np->end_point = temp->last_list;
-        if (!np->end_point) {
-            np->start_point = NULL;
+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]);
         }
 
-        free(temp);
+        free(n.children);
     }
 }
 
-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;
-        }
+void dfs_recursive(struct node n) {
+    printf("%d\n", n.id);
 
-        free(temp);
+    if (n.children) {
+        for (size_t i = 0; i < n.children_size; ++i) {
+            dfs_recursive(n.children[i]);
+        }
     }
 }
 
-void create_tree(node *n, int num_row, int num_child) {
-    n->ID = num_row;
-    if (num_row == 0) {
-        return;
+void dfs_recursive_postorder(struct node n) {
+    for (size_t i = 0; i < n.children_size; ++i) {
+        dfs_recursive_postorder(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;
-    }
+    printf("%d\n", n.id);
 }
 
-void DFS_recursive(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]);
+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);
+        dfs_recursive_inorder_btree(n.children[1]);
+        break;
+    case 1:
+        dfs_recursive_inorder_btree(n.children[0]);
+        printf("%d\n", n.id);
+        break;
+    case 0:
+        printf("%d\n", n.id);
+        break;
+    default:
+        printf("This is not a binary tree.\n");
+        break;
     }
 }
 
-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;
 }
-