Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/c/chapter_tree/CMakeLists.txt

@@ -0,0 +1,6 @@
+add_executable(avl_tree avl_tree.c)
+add_executable(binary_tree binary_tree.c)
+add_executable(binary_tree_bfs binary_tree_bfs.c)
+add_executable(binary_tree_dfs binary_tree_dfs.c)
+add_executable(binary_search_tree binary_search_tree.c)
+add_executable(array_binary_tree array_binary_tree.c)

ja/codes/c/chapter_tree/array_binary_tree.c

@@ -0,0 +1,166 @@
+/**
+ * File: array_binary_tree.c
+ * Created Time: 2023-07-29
+ * Author: Gonglja (glj0@outlook.com)
+ */
+
+#include "../utils/common.h"
+
+/* 配列表現による二分木の構造体 */
+typedef struct {
+    int *tree;
+    int size;
+} ArrayBinaryTree;
+
+/* コンストラクタ */
+ArrayBinaryTree *newArrayBinaryTree(int *arr, int arrSize) {
+    ArrayBinaryTree *abt = (ArrayBinaryTree *)malloc(sizeof(ArrayBinaryTree));
+    abt->tree = malloc(sizeof(int) * arrSize);
+    memcpy(abt->tree, arr, sizeof(int) * arrSize);
+    abt->size = arrSize;
+    return abt;
+}
+
+/* デストラクタ */
+void delArrayBinaryTree(ArrayBinaryTree *abt) {
+    free(abt->tree);
+    free(abt);
+}
+
+/* リスト容量 */
+int size(ArrayBinaryTree *abt) {
+    return abt->size;
+}
+
+/* インデックス i のノードの値を取得 */
+int val(ArrayBinaryTree *abt, int i) {
+    // インデックスが範囲外なら、空きを表す INT_MAX を返す
+    if (i < 0 || i >= size(abt))
+        return INT_MAX;
+    return abt->tree[i];
+}
+
+/* インデックス i のノードの左子ノードのインデックスを取得 */
+int left(int i) {
+    return 2 * i + 1;
+}
+
+/* インデックス i のノードの右子ノードのインデックスを取得 */
+int right(int i) {
+    return 2 * i + 2;
+}
+
+/* インデックス i のノードの親ノードのインデックスを取得 */
+int parent(int i) {
+    return (i - 1) / 2;
+}
+
+/* レベル順走査 */
+int *levelOrder(ArrayBinaryTree *abt, int *returnSize) {
+    int *res = (int *)malloc(sizeof(int) * size(abt));
+    int index = 0;
+    // 配列を直接走査する
+    for (int i = 0; i < size(abt); i++) {
+        if (val(abt, i) != INT_MAX)
+            res[index++] = val(abt, i);
+    }
+    *returnSize = index;
+    return res;
+}
+
+/* 深さ優先探索 */
+void dfs(ArrayBinaryTree *abt, int i, char *order, int *res, int *index) {
+    // 空きスロットなら返す
+    if (val(abt, i) == INT_MAX)
+        return;
+    // 先行順走査
+    if (strcmp(order, "pre") == 0)
+        res[(*index)++] = val(abt, i);
+    dfs(abt, left(i), order, res, index);
+    // 中順走査
+    if (strcmp(order, "in") == 0)
+        res[(*index)++] = val(abt, i);
+    dfs(abt, right(i), order, res, index);
+    // 後順走査
+    if (strcmp(order, "post") == 0)
+        res[(*index)++] = val(abt, i);
+}
+
+/* 先行順走査 */
+int *preOrder(ArrayBinaryTree *abt, int *returnSize) {
+    int *res = (int *)malloc(sizeof(int) * size(abt));
+    int index = 0;
+    dfs(abt, 0, "pre", res, &index);
+    *returnSize = index;
+    return res;
+}
+
+/* 中順走査 */
+int *inOrder(ArrayBinaryTree *abt, int *returnSize) {
+    int *res = (int *)malloc(sizeof(int) * size(abt));
+    int index = 0;
+    dfs(abt, 0, "in", res, &index);
+    *returnSize = index;
+    return res;
+}
+
+/* 後順走査 */
+int *postOrder(ArrayBinaryTree *abt, int *returnSize) {
+    int *res = (int *)malloc(sizeof(int) * size(abt));
+    int index = 0;
+    dfs(abt, 0, "post", res, &index);
+    *returnSize = index;
+    return res;
+}
+
+/* Driver Code */
+int main() {
+    // 二分木を初期化する
+    // 空き位置 NULL は INT_MAX で表す
+    int arr[] = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};
+    int arrSize = sizeof(arr) / sizeof(arr[0]);
+    TreeNode *root = arrayToTree(arr, arrSize);
+    printf("\n二分木を初期化\n");
+    printf("二分木の配列表現：\n");
+    printArray(arr, arrSize);
+    printf("二分木の連結リスト表現：\n");
+    printTree(root);
+
+    ArrayBinaryTree *abt = newArrayBinaryTree(arr, arrSize);
+
+    // ノードにアクセス
+    int i = 1;
+    int l = left(i), r = right(i), p = parent(i);
+    printf("\n現在のノードのインデックスは %d、値は %d\n", i, val(abt, i));
+    printf("左の子ノードのインデックスは %d、値は %d\n", l, l < arrSize ? val(abt, l) : INT_MAX);
+    printf("右の子ノードのインデックスは %d、値は %d\n", r, r < arrSize ? val(abt, r) : INT_MAX);
+    printf("親ノードのインデックスは %d、値は %d\n", p, p < arrSize ? val(abt, p) : INT_MAX);
+
+    // 木を走査
+    int returnSize;
+    int *res;
+
+    res = levelOrder(abt, &returnSize);
+    printf("\nレベル順走査： ");
+    printArray(res, returnSize);
+    free(res);
+
+    res = preOrder(abt, &returnSize);
+    printf("前順走査： ");
+    printArray(res, returnSize);
+    free(res);
+
+    res = inOrder(abt, &returnSize);
+    printf("中順走査： ");
+    printArray(res, returnSize);
+    free(res);
+
+    res = postOrder(abt, &returnSize);
+    printf("後順走査： ");
+    printArray(res, returnSize);
+    free(res);
+
+    // メモリを解放する
+    delArrayBinaryTree(abt);
+    return 0;
+}

ja/codes/c/chapter_tree/avl_tree.c

@@ -0,0 +1,259 @@
+/**
+ * File: avl_tree.c
+ * Created Time: 2023-01-15
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#include "../utils/common.h"
+
+/* AVL 木構造体 */
+typedef struct {
+    TreeNode *root;
+} AVLTree;
+
+/* コンストラクタ */
+AVLTree *newAVLTree() {
+    AVLTree *tree = (AVLTree *)malloc(sizeof(AVLTree));
+    tree->root = NULL;
+    return tree;
+}
+
+/* デストラクタ */
+void delAVLTree(AVLTree *tree) {
+    freeMemoryTree(tree->root);
+    free(tree);
+}
+
+/* ノードの高さを取得 */
+int height(TreeNode *node) {
+    // 空ノードの高さは -1、葉ノードの高さは 0
+    if (node != NULL) {
+        return node->height;
+    }
+    return -1;
+}
+
+/* ノードの高さを更新する */
+void updateHeight(TreeNode *node) {
+    int lh = height(node->left);
+    int rh = height(node->right);
+    // ノードの高さは最も高い部分木の高さ + 1 に等しい
+    if (lh > rh) {
+        node->height = lh + 1;
+    } else {
+        node->height = rh + 1;
+    }
+}
+
+/* 平衡係数を取得 */
+int balanceFactor(TreeNode *node) {
+    // 空ノードの平衡係数は 0
+    if (node == NULL) {
+        return 0;
+    }
+    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ
+    return height(node->left) - height(node->right);
+}
+
+/* 右回転 */
+TreeNode *rightRotate(TreeNode *node) {
+    TreeNode *child, *grandChild;
+    child = node->left;
+    grandChild = child->right;
+    // child を支点として node を右回転させる
+    child->right = node;
+    node->left = grandChild;
+    // ノードの高さを更新する
+    updateHeight(node);
+    updateHeight(child);
+    // 回転後の部分木の根ノードを返す
+    return child;
+}
+
+/* 左回転 */
+TreeNode *leftRotate(TreeNode *node) {
+    TreeNode *child, *grandChild;
+    child = node->right;
+    grandChild = child->left;
+    // child を支点として node を左回転させる
+    child->left = node;
+    node->right = grandChild;
+    // ノードの高さを更新する
+    updateHeight(node);
+    updateHeight(child);
+    // 回転後の部分木の根ノードを返す
+    return child;
+}
+
+/* 回転操作を行い、この部分木の平衡を回復する */
+TreeNode *rotate(TreeNode *node) {
+    // ノード node の平衡係数を取得
+    int bf = balanceFactor(node);
+    // 左に偏った木
+    if (bf > 1) {
+        if (balanceFactor(node->left) >= 0) {
+            // 右回転
+            return rightRotate(node);
+        } else {
+            // 左回転してから右回転
+            node->left = leftRotate(node->left);
+            return rightRotate(node);
+        }
+    }
+    // 右に偏った木
+    if (bf < -1) {
+        if (balanceFactor(node->right) <= 0) {
+            // 左回転
+            return leftRotate(node);
+        } else {
+            // 右回転してから左回転
+            node->right = rightRotate(node->right);
+            return leftRotate(node);
+        }
+    }
+    // 平衡木なので回転不要、そのまま返す
+    return node;
+}
+
+/* ノードを再帰的に挿入する（補助関数） */
+TreeNode *insertHelper(TreeNode *node, int val) {
+    if (node == NULL) {
+        return newTreeNode(val);
+    }
+    /* 1. 挿入位置を探索してノードを挿入 */
+    if (val < node->val) {
+        node->left = insertHelper(node->left, val);
+    } else if (val > node->val) {
+        node->right = insertHelper(node->right, val);
+    } else {
+        // 重複ノードは挿入せず、そのまま返す
+        return node;
+    }
+    // ノードの高さを更新する
+    updateHeight(node);
+    /* 2. 回転操作を行い、部分木の平衡を回復する */
+    node = rotate(node);
+    // 部分木の根ノードを返す
+    return node;
+}
+
+/* ノードを挿入 */
+void insert(AVLTree *tree, int val) {
+    tree->root = insertHelper(tree->root, val);
+}
+
+/* ノードを再帰的に削除する（補助関数） */
+TreeNode *removeHelper(TreeNode *node, int val) {
+    TreeNode *child, *grandChild;
+    if (node == NULL) {
+        return NULL;
+    }
+    /* 1. ノードを探索して削除 */
+    if (val < node->val) {
+        node->left = removeHelper(node->left, val);
+    } else if (val > node->val) {
+        node->right = removeHelper(node->right, val);
+    } else {
+        if (node->left == NULL || node->right == NULL) {
+            child = node->left;
+            if (node->right != NULL) {
+                child = node->right;
+            }
+            // 子ノード数 = 0 の場合、node をそのまま削除して返す
+            if (child == NULL) {
+                return NULL;
+            } else {
+                // 子ノード数 = 1 の場合、node をそのまま削除する
+                node = child;
+            }
+        } else {
+            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える
+            TreeNode *temp = node->right;
+            while (temp->left != NULL) {
+                temp = temp->left;
+            }
+            int tempVal = temp->val;
+            node->right = removeHelper(node->right, temp->val);
+            node->val = tempVal;
+        }
+    }
+    // ノードの高さを更新する
+    updateHeight(node);
+    /* 2. 回転操作を行い、部分木の平衡を回復する */
+    node = rotate(node);
+    // 部分木の根ノードを返す
+    return node;
+}
+
+/* ノードを削除 */
+// stdio.h を導入しているため、ここでは remove 識別子を使えない
+void removeItem(AVLTree *tree, int val) {
+    TreeNode *root = removeHelper(tree->root, val);
+}
+
+/* ノードを探索 */
+TreeNode *search(AVLTree *tree, int val) {
+    TreeNode *cur = tree->root;
+    // ループで探索し、葉ノードを越えたら抜ける
+    while (cur != NULL) {
+        if (cur->val < val) {
+            // 目標ノードは cur の右部分木にある
+            cur = cur->right;
+        } else if (cur->val > val) {
+            // 目標ノードは cur の左部分木にある
+            cur = cur->left;
+        } else {
+            // 目標ノードが見つかったらループを抜ける
+            break;
+        }
+    }
+    // 目標ノードが見つかったらループを抜ける
+    return cur;
+}
+
+void testInsert(AVLTree *tree, int val) {
+    insert(tree, val);
+    printf("\nノード %d を挿入した後、AVL 木は \n", val);
+    printTree(tree->root);
+}
+
+void testRemove(AVLTree *tree, int val) {
+    removeItem(tree, val);
+    printf("\nノード %d を削除した後、AVL 木は \n", val);
+    printTree(tree->root);
+}
+
+/* Driver Code */
+int main() {
+    /* 空の AVL 木を初期化する */
+    AVLTree *tree = (AVLTree *)newAVLTree();
+    /* ノードを挿入 */
+    // ノード挿入後に AVL 木がどのように平衡を保つかに注目してほしい
+    testInsert(tree, 1);
+    testInsert(tree, 2);
+    testInsert(tree, 3);
+    testInsert(tree, 4);
+    testInsert(tree, 5);
+    testInsert(tree, 8);
+    testInsert(tree, 7);
+    testInsert(tree, 9);
+    testInsert(tree, 10);
+    testInsert(tree, 6);
+
+    /* 重複ノードを挿入する */
+    testInsert(tree, 7);
+
+    /* ノードを削除 */
+    // ノード削除後に AVL 木がどのように平衡を保つかに注目してほしい
+    testRemove(tree, 8); // 次数 0 のノードを削除する
+    testRemove(tree, 5); // 次数 1 のノードを削除する
+    testRemove(tree, 4); // 次数 2 のノードを削除する
+
+    /* ノードを検索 */
+    TreeNode *node = search(tree, 7);
+    printf("\n見つかったノードオブジェクトのノード値 = %d \n", node->val);
+
+    // メモリを解放する
+    delAVLTree(tree);
+    return 0;
+}

ja/codes/c/chapter_tree/binary_search_tree.c

@@ -0,0 +1,171 @@
+/**
+ * File: binary_search_tree.c
+ * Created Time: 2023-01-11
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#include "../utils/common.h"
+
+/* 二分探索木構造体 */
+typedef struct {
+    TreeNode *root;
+} BinarySearchTree;
+
+/* コンストラクタ */
+BinarySearchTree *newBinarySearchTree() {
+    // 空の木を初期化する
+    BinarySearchTree *bst = (BinarySearchTree *)malloc(sizeof(BinarySearchTree));
+    bst->root = NULL;
+    return bst;
+}
+
+/* デストラクタ */
+void delBinarySearchTree(BinarySearchTree *bst) {
+    freeMemoryTree(bst->root);
+    free(bst);
+}
+
+/* 二分木の根ノードを取得 */
+TreeNode *getRoot(BinarySearchTree *bst) {
+    return bst->root;
+}
+
+/* ノードを探索 */
+TreeNode *search(BinarySearchTree *bst, int num) {
+    TreeNode *cur = bst->root;
+    // ループで探索し、葉ノードを越えたら抜ける
+    while (cur != NULL) {
+        if (cur->val < num) {
+            // 目標ノードは cur の右部分木にある
+            cur = cur->right;
+        } else if (cur->val > num) {
+            // 目標ノードは cur の左部分木にある
+            cur = cur->left;
+        } else {
+            // 目標ノードが見つかったらループを抜ける
+            break;
+        }
+    }
+    // 目標ノードを返す
+    return cur;
+}
+
+/* ノードを挿入 */
+void insert(BinarySearchTree *bst, int num) {
+    // 木が空なら、根ノードを初期化する
+    if (bst->root == NULL) {
+        bst->root = newTreeNode(num);
+        return;
+    }
+    TreeNode *cur = bst->root, *pre = NULL;
+    // ループで探索し、葉ノードを越えたら抜ける
+    while (cur != NULL) {
+        // 重複ノードが見つかったら、直ちに返す
+        if (cur->val == num) {
+            return;
+        }
+        pre = cur;
+        if (cur->val < num) {
+            // 挿入位置は cur の右部分木にある
+            cur = cur->right;
+        } else {
+            // 挿入位置は cur の左部分木にある
+            cur = cur->left;
+        }
+    }
+    // ノードを挿入
+    TreeNode *node = newTreeNode(num);
+    if (pre->val < num) {
+        pre->right = node;
+    } else {
+        pre->left = node;
+    }
+}
+
+/* ノードを削除 */
+// stdio.h を導入しているため、ここでは remove 識別子を使えない
+void removeItem(BinarySearchTree *bst, int num) {
+    // 木が空なら、そのまま早期リターンする
+    if (bst->root == NULL)
+        return;
+    TreeNode *cur = bst->root, *pre = NULL;
+    // ループで探索し、葉ノードを越えたら抜ける
+    while (cur != NULL) {
+        // 削除対象のノードが見つかったら、ループを抜ける
+        if (cur->val == num)
+            break;
+        pre = cur;
+        if (cur->val < num) {
+            // 削除対象ノードは root の右部分木にある
+            cur = cur->right;
+        } else {
+            // 削除対象ノードは root の左部分木にある
+            cur = cur->left;
+        }
+    }
+    // 削除対象ノードがなければそのまま返す
+    if (cur == NULL)
+        return;
+    // 削除対象ノードに子ノードがあるかを判定する
+    if (cur->left == NULL || cur->right == NULL) {
+        /* 子ノード数 = 0 or 1 */
+        // 子ノード数 = 0 / 1 のとき、child = nullptr / その子ノード
+        TreeNode *child = cur->left != NULL ? cur->left : cur->right;
+        // ノード cur を削除する
+        if (pre->left == cur) {
+            pre->left = child;
+        } else {
+            pre->right = child;
+        }
+        // メモリを解放する
+        free(cur);
+    } else {
+        /* 子ノード数 = 2 */
+        // 中順走査における cur の次ノードを取得
+        TreeNode *tmp = cur->right;
+        while (tmp->left != NULL) {
+            tmp = tmp->left;
+        }
+        int tmpVal = tmp->val;
+        // ノード tmp を再帰的に削除
+        removeItem(bst, tmp->val);
+        // tmp で cur を上書きする
+        cur->val = tmpVal;
+    }
+}
+
+/* Driver Code */
+int main() {
+    /* 二分探索木を初期化 */
+    int nums[] = {8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15};
+    BinarySearchTree *bst = newBinarySearchTree();
+    for (int i = 0; i < sizeof(nums) / sizeof(int); i++) {
+        insert(bst, nums[i]);
+    }
+    printf("初期化した二分木は\n");
+    printTree(getRoot(bst));
+
+    /* ノードを探索 */
+    TreeNode *node = search(bst, 7);
+    printf("見つかったノードオブジェクトのノード値 = %d\n", node->val);
+
+    /* ノードを挿入 */
+    insert(bst, 16);
+    printf("ノード 16 を挿入した後、二分木は\n");
+    printTree(getRoot(bst));
+
+    /* ノードを削除 */
+    removeItem(bst, 1);
+    printf("ノード 1 を削除した後、二分木は\n");
+    printTree(getRoot(bst));
+    removeItem(bst, 2);
+    printf("ノード 2 を削除した後、二分木は\n");
+    printTree(getRoot(bst));
+    removeItem(bst, 4);
+    printf("ノード 4 を削除した後、二分木は\n");
+    printTree(getRoot(bst));
+
+    // メモリを解放する
+    delBinarySearchTree(bst);
+    return 0;
+}

ja/codes/c/chapter_tree/binary_tree.c

@@ -0,0 +1,43 @@
+/**
+ * File: binary_tree.c
+ * Created Time: 2023-01-11
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#include "../utils/common.h"
+
+/* Driver Code */
+int main() {
+    /* 二分木を初期化 */
+    // ノードを初期化
+    TreeNode *n1 = newTreeNode(1);
+    TreeNode *n2 = newTreeNode(2);
+    TreeNode *n3 = newTreeNode(3);
+    TreeNode *n4 = newTreeNode(4);
+    TreeNode *n5 = newTreeNode(5);
+    // ノード間の参照（ポインタ）を構築する
+    n1->left = n2;
+    n1->right = n3;
+    n2->left = n4;
+    n2->right = n5;
+    printf("二分木を初期化\n");
+    printTree(n1);
+
+    /* ノードの挿入と削除 */
+    TreeNode *P = newTreeNode(0);
+    // n1 -> n2 の間にノード P を挿入
+    n1->left = P;
+    P->left = n2;
+    printf("ノード P を挿入した後\n");
+    printTree(n1);
+
+    // ノード P を削除
+    n1->left = n2;
+    // メモリを解放する
+    free(P);
+    printf("ノード P を削除した後\n");
+    printTree(n1);
+
+    freeMemoryTree(n1);
+    return 0;
+}

ja/codes/c/chapter_tree/binary_tree_bfs.c

@@ -0,0 +1,73 @@
+/**
+ * File: binary_tree_bfs.c
+ * Created Time: 2023-01-11
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#include "../utils/common.h"
+
+#define MAX_SIZE 100
+
+/* レベル順走査 */
+int *levelOrder(TreeNode *root, int *size) {
+    /* 補助キュー */
+    int front, rear;
+    int index, *arr;
+    TreeNode *node;
+    TreeNode **queue;
+
+    /* 補助キュー */
+    queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_SIZE);
+    // キューへのポインタ
+    front = 0, rear = 0;
+    // 根ノードを追加する
+    queue[rear++] = root;
+    // 走査順序を保存するためのリストを初期化する
+    /* 補助配列 */
+    arr = (int *)malloc(sizeof(int) * MAX_SIZE);
+    // 配列ポインタ
+    index = 0;
+    while (front < rear) {
+        // デキュー
+        node = queue[front++];
+        // ノードの値を保存する
+        arr[index++] = node->val;
+        if (node->left != NULL) {
+            // 左子ノードをキューに追加
+            queue[rear++] = node->left;
+        }
+        if (node->right != NULL) {
+            // 右子ノードをキューに追加
+            queue[rear++] = node->right;
+        }
+    }
+    // 配列長の値を更新
+    *size = index;
+    arr = realloc(arr, sizeof(int) * (*size));
+
+    // 補助配列の領域を解放する
+    free(queue);
+    return arr;
+}
+
+/* Driver Code */
+int main() {
+    /* 二分木を初期化 */
+    // ここでは、配列から直接二分木を生成する関数を利用する
+    int nums[] = {1, 2, 3, 4, 5, 6, 7};
+    int size = sizeof(nums) / sizeof(int);
+    TreeNode *root = arrayToTree(nums, size);
+    printf("二分木を初期化\n");
+    printTree(root);
+
+    /* レベル順走査 */
+    // 配列の長さを渡す必要がある
+    int *arr = levelOrder(root, &size);
+    printf("レベル順走査のノード出力シーケンス = ");
+    printArray(arr, size);
+
+    // メモリを解放する
+    freeMemoryTree(root);
+    free(arr);
+    return 0;
+}

ja/codes/c/chapter_tree/binary_tree_dfs.c

@@ -0,0 +1,75 @@
+/**
+ * File: binary_tree_dfs.c
+ * Created Time: 2023-01-11
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#include "../utils/common.h"
+
+#define MAX_SIZE 100
+
+// 走査順序を格納するための補助配列
+int arr[MAX_SIZE];
+
+/* 先行順走査 */
+void preOrder(TreeNode *root, int *size) {
+    if (root == NULL)
+        return;
+    // 訪問順序：根ノード -> 左部分木 -> 右部分木
+    arr[(*size)++] = root->val;
+    preOrder(root->left, size);
+    preOrder(root->right, size);
+}
+
+/* 中順走査 */
+void inOrder(TreeNode *root, int *size) {
+    if (root == NULL)
+        return;
+    // 訪問優先順: 左部分木 -> 根ノード -> 右部分木
+    inOrder(root->left, size);
+    arr[(*size)++] = root->val;
+    inOrder(root->right, size);
+}
+
+/* 後順走査 */
+void postOrder(TreeNode *root, int *size) {
+    if (root == NULL)
+        return;
+    // 訪問優先順: 左部分木 -> 右部分木 -> 根ノード
+    postOrder(root->left, size);
+    postOrder(root->right, size);
+    arr[(*size)++] = root->val;
+}
+
+/* Driver Code */
+int main() {
+    /* 二分木を初期化 */
+    // ここでは、配列から直接二分木を生成する関数を利用する
+    int nums[] = {1, 2, 3, 4, 5, 6, 7};
+    int size = sizeof(nums) / sizeof(int);
+    TreeNode *root = arrayToTree(nums, size);
+    printf("二分木を初期化\n");
+    printTree(root);
+
+    /* 先行順走査 */
+    // 補助配列を初期化する
+    size = 0;
+    preOrder(root, &size);
+    printf("前順走査のノード出力シーケンス = ");
+    printArray(arr, size);
+
+    /* 中順走査 */
+    size = 0;
+    inOrder(root, &size);
+    printf("中順走査のノード出力シーケンス = ");
+    printArray(arr, size);
+
+    /* 後順走査 */
+    size = 0;
+    postOrder(root, &size);
+    printf("後順走査のノード出力シーケンス = ");
+    printArray(arr, size);
+
+    freeMemoryTree(root);
+    return 0;
+}