MENU
  1. ホーム
  2. C言語
  3. C言語でのB木の実装方法：完全ガイド

C言語でのB木の実装方法：完全ガイド

C言語

B木（B-Tree）は、効率的なデータ構造としてデータベースやファイルシステムで広く利用されています。特に、大量のデータを高速に検索、挿入、削除するための優れた手段として知られています。本記事では、B木の基本概念からC言語での具体的な実装方法までを詳しく解説します。プログラミング初心者から中級者まで、誰もが理解できるようにステップバイステップで説明しますので、ぜひ最後までご覧ください。

目次

B木とは何か

B木（B-Tree）は、バランスの取れたツリー構造であり、多くの子ノードを持つことができる自己平衡二分探索木の一種です。B木は、木の高さを低く保つことで、大量のデータを効率的に管理します。このデータ構造は、ディスクアクセスを最小限に抑え、検索、挿入、削除の各操作を高速に行えるため、データベースやファイルシステムなどの分野で広く利用されています。B木の主な特徴として、各ノードが複数のキーと子ポインタを持ち、すべての葉ノードが同じ深さにあることが挙げられます。

B木の用途と利点

用途

B木は、大規模なデータセットを扱う際に特に有効です。以下は、B木がよく使用される主な用途です：

データベース管理システム

B木は、データベース管理システム（DBMS）でインデックスとして広く使用されています。これにより、大量のデータから特定のレコードを迅速に検索、挿入、削除することができます。

ファイルシステム

多くのファイルシステムで、ファイルのメタデータの管理やディレクトリの構造を効率的に管理するためにB木が使用されています。これにより、ファイルの検索やディレクトリの操作が高速化されます。

メモリ管理

B木は、メモリ管理やキャッシュ管理においても利用されます。ヒープ管理やスワップ領域の管理などで、効率的なメモリアロケーションが可能です。

利点

B木には以下のような利点があります：

効率的な操作

B木は、検索、挿入、削除の各操作がO(log n)の時間複雑度で行えます。これにより、大量のデータを扱う際にも高速な処理が可能です。

バランスの維持

B木は常にバランスが取れているため、どの操作においても一貫した性能を発揮します。これは、木の高さが低く保たれるためです。

ディスクアクセスの最小化

B木の構造は、ディスクアクセスを最小限に抑えるように設計されています。これにより、ディスクI/Oのコストが高い環境でも高いパフォーマンスを発揮します。

動的なデータの管理

B木は、データの挿入や削除が頻繁に行われる環境においても、効率的に動作します。ノードの分割や統合により、常にバランスが保たれます。

これらの用途と利点により、B木は多くのシステムやアプリケーションで重要な役割を果たしています。

C言語でのB木の基本構造

B木をC言語で実装するためには、B木の基本構造を理解することが重要です。B木は、ノード（Node）と呼ばれる基本単位で構成され、それぞれのノードは複数のキーと子ポインタを持ちます。

ノードの定義

C言語でB木のノードを定義するには、次のような構造体を使用します：

#define MAX_KEYS (2 * T - 1)
#define MIN_KEYS (T - 1)
#define MAX_CHILDREN (2 * T)

typedef struct BTreeNode {
    int keys[MAX_KEYS];           // ノードが保持するキーの配列
    struct BTreeNode* children[MAX_CHILDREN];  // 子ノードへのポインタの配列
    int numKeys;                  // ノードに含まれるキーの数
    bool isLeaf;                  // 葉ノードかどうかのフラグ
} BTreeNode;

この構造体は、B木のノードを表しています。keysはノードが保持するキーの配列、childrenは子ノードへのポインタの配列、numKeysはノードに含まれるキーの数、isLeafはそのノードが葉ノードであるかどうかを示します。

基本定数の定義

B木の定数Tは、各ノードが保持できる最小および最大のキー数を決定します。Tの値が大きいほど、各ノードはより多くのキーを持つことができます。ここでは例として、Tを3と定義します：

#define T 3

ノードの初期化

次に、新しいノードを初期化する関数を定義します：

BTreeNode* createNode(bool isLeaf) {
    BTreeNode* newNode = (BTreeNode*)malloc(sizeof(BTreeNode));
    newNode->isLeaf = isLeaf;
    newNode->numKeys = 0;
    for (int i = 0; i < MAX_CHILDREN; i++) {
        newNode->children[i] = NULL;
    }
    return newNode;
}

この関数は、新しいノードを作成し、そのノードが葉ノードかどうかを設定します。すべての子ポインタをNULLに初期化し、キーの数を0に設定します。

B木の基本操作

B木の操作には、検索、挿入、削除があります。これらの操作は、次のセクションで詳細に説明しますが、基本構造を理解することで、これらの操作の実装が容易になります。

以上が、C言語でB木を実装するための基本構造の説明です。次のセクションでは、具体的なノードの操作方法について解説します。

ノードの定義と初期化

B木のノードを定義し、初期化する方法について詳しく見ていきます。これにより、B木の構造を理解し、具体的な操作に備えることができます。

ノードの定義

B木のノードは、複数のキーと子ポインタを持つ構造体として定義されます。C言語での具体的な定義は次の通りです：

#define MAX_KEYS (2 * T - 1) // ノードが持つ最大キー数
#define MAX_CHILDREN (2 * T) // ノードが持つ最大子ノード数

typedef struct BTreeNode {
    int keys[MAX_KEYS];           // ノード内のキー
    struct BTreeNode* children[MAX_CHILDREN];  // 子ノードへのポインタ
    int numKeys;                  // 現在のキー数
    bool isLeaf;                  // 葉ノードかどうか
} BTreeNode;

この定義により、B木のノードはキーの配列、子ノードへのポインタの配列、現在のキー数、葉ノードフラグを持つことになります。

ノードの初期化

新しいノードを初期化するための関数を作成します。この関数は、新しいノードのメモリを確保し、初期値を設定します：

#include <stdlib.h>
#include <stdbool.h>

BTreeNode* createNode(bool isLeaf) {
    BTreeNode* newNode = (BTreeNode*)malloc(sizeof(BTreeNode));
    newNode->isLeaf = isLeaf;
    newNode->numKeys = 0;
    for (int i = 0; i < MAX_CHILDREN; i++) {
        newNode->children[i] = NULL;
    }
    return newNode;
}

この関数では、新しいノードのメモリを動的に確保し、葉ノードフラグを設定します。また、キーの数を0に初期化し、子ノードへのポインタをすべてNULLに設定します。

ノードの挿入操作の準備

B木に新しいキーを挿入する際には、まずルートノードが満杯かどうかを確認し、必要に応じてノードを分割します。これにより、木全体のバランスが保たれます。以下に、ルートノードが満杯の場合の処理を示します：

void insert(BTreeNode** root, int key) {
    BTreeNode* r = *root;
    if (r->numKeys == MAX_KEYS) {
        BTreeNode* s = createNode(false);
        *root = s;
        s->children[0] = r;
        splitChild(s, 0, r);
        insertNonFull(s, key);
    } else {
        insertNonFull(r, key);
    }
}

この関数では、ルートノードが満杯の場合、新しいノードを作成し、ルートノードを分割してキーを挿入します。

ノードの分割

ノードを分割する関数は次のように実装されます：

void splitChild(BTreeNode* x, int i, BTreeNode* y) {
    BTreeNode* z = createNode(y->isLeaf);
    z->numKeys = MIN_KEYS;
    for (int j = 0; j < MIN_KEYS; j++) {
        z->keys[j] = y->keys[j + T];
    }
    if (!y->isLeaf) {
        for (int j = 0; j <= MIN_KEYS; j++) {
            z->children[j] = y->children[j + T];
        }
    }
    y->numKeys = MIN_KEYS;
    for (int j = x->numKeys; j >= i + 1; j--) {
        x->children[j + 1] = x->children[j];
    }
    x->children[i + 1] = z;
    for (int j = x->numKeys - 1; j >= i; j--) {
        x->keys[j + 1] = x->keys[j];
    }
    x->keys[i] = y->keys[T - 1];
    x->numKeys++;
}

この関数は、ノードyを分割し、新しいノードzを作成して適切に配置します。

これで、B木のノードの定義と初期化、および挿入操作の準備が整いました。次のセクションでは、具体的な挿入操作の実装方法について説明します。

ノードの挿入操作

B木に新しいノードを挿入するための具体的なアルゴリズムと実装方法について説明します。ここでは、B木が常にバランスを保つようにノードを適切に分割し、キーを挿入する方法を詳しく見ていきます。

ノードへの挿入操作

B木にキーを挿入する場合、まず対象ノードが満杯でないことを確認します。満杯でない場合、適切な位置にキーを挿入します。

void insertNonFull(BTreeNode* x, int key) {
    int i = x->numKeys - 1;

    if (x->isLeaf) {
        while (i >= 0 && key < x->keys[i]) {
            x->keys[i + 1] = x->keys[i];
            i--;
        }
        x->keys[i + 1] = key;
        x->numKeys++;
    } else {
        while (i >= 0 && key < x->keys[i]) {
            i--;
        }
        i++;
        if (x->children[i]->numKeys == MAX_KEYS) {
            splitChild(x, i, x->children[i]);
            if (key > x->keys[i]) {
                i++;
            }
        }
        insertNonFull(x->children[i], key);
    }
}

この関数は、ノードが葉の場合と内部ノードの場合に分けて処理を行います。葉ノードの場合、適切な位置にキーを挿入し、内部ノードの場合、子ノードが満杯であれば分割し、適切な子ノードに再帰的に挿入します。

ルートノードへの挿入

ルートノードが満杯である場合、新しいルートノードを作成し、ルートノードを分割してから挿入を行います。

void insert(BTreeNode** root, int key) {
    BTreeNode* r = *root;
    if (r->numKeys == MAX_KEYS) {
        BTreeNode* s = createNode(false);
        *root = s;
        s->children[0] = r;
        splitChild(s, 0, r);
        insertNonFull(s, key);
    } else {
        insertNonFull(r, key);
    }
}

この関数は、ルートノードが満杯の場合に新しいノードを作成し、ルートノードを分割してから挿入します。これにより、B木のバランスが保たれます。

ノードの分割操作

ノードを分割するための具体的な実装は以下の通りです。

void splitChild(BTreeNode* x, int i, BTreeNode* y) {
    BTreeNode* z = createNode(y->isLeaf);
    z->numKeys = MIN_KEYS;
    for (int j = 0; j < MIN_KEYS; j++) {
        z->keys[j] = y->keys[j + T];
    }
    if (!y->isLeaf) {
        for (int j = 0; j <= MIN_KEYS; j++) {
            z->children[j] = y->children[j + T];
        }
    }
    y->numKeys = MIN_KEYS;
    for (int j = x->numKeys; j >= i + 1; j--) {
        x->children[j + 1] = x->children[j];
    }
    x->children[i + 1] = z;
    for (int j = x->numKeys - 1; j >= i; j--) {
        x->keys[j + 1] = x->keys[j];
    }
    x->keys[i] = y->keys[T - 1];
    x->numKeys++;
}

この関数は、ノードyを分割し、新しいノードzを作成して適切に配置します。分割後、親ノードxのキーと子ポインタが更新されます。

これで、B木へのキーの挿入操作が完了しました。次のセクションでは、B木からノードを削除する方法について説明します。

ノードの削除操作

B木からノードを削除するアルゴリズムとその実装方法について詳しく説明します。B木は常にバランスを保つ必要があるため、削除操作には特別な処理が必要です。

ノードの削除操作の概要

B木からキーを削除する際には、削除後も木の特性を維持するために、いくつかの再構成操作が行われます。以下に、削除操作の主なステップを示します。

削除操作のアルゴリズム

B木からキーを削除するアルゴリズムは、削除するキーがノード内にある場合と、子ノードにある場合で異なります。以下は、キーを削除するための関数の実装です。

void deleteKey(BTreeNode* node, int key) {
    int idx = findKey(node, key);

    if (idx < node->numKeys && node->keys[idx] == key) {
        if (node->isLeaf) {
            removeFromLeaf(node, idx);
        } else {
            removeFromNonLeaf(node, idx);
        }
    } else {
        if (node->isLeaf) {
            printf("The key %d is not present in the tree\n", key);
            return;
        }

        bool flag = ((idx == node->numKeys) ? true : false);

        if (node->children[idx]->numKeys < T) {
            fill(node, idx);
        }

        if (flag && idx > node->numKeys) {
            deleteKey(node->children[idx - 1], key);
        } else {
            deleteKey(node->children[idx], key);
        }
    }
}

この関数では、キーがノード内にある場合とない場合で処理を分けています。また、必要に応じてノードを再構成するための補助関数を呼び出します。

葉ノードからの削除

葉ノードからキーを削除する関数は次のように実装します。

void removeFromLeaf(BTreeNode* node, int idx) {
    for (int i = idx + 1; i < node->numKeys; ++i) {
        node->keys[i - 1] = node->keys[i];
    }
    node->numKeys--;
}

この関数は、葉ノードから指定されたキーを削除し、キーの数を減少させます。

内部ノードからの削除

内部ノードからキーを削除する関数は次のように実装します。

void removeFromNonLeaf(BTreeNode* node, int idx) {
    int key = node->keys[idx];

    if (node->children[idx]->numKeys >= T) {
        int pred = getPredecessor(node, idx);
        node->keys[idx] = pred;
        deleteKey(node->children[idx], pred);
    } else if (node->children[idx + 1]->numKeys >= T) {
        int succ = getSuccessor(node, idx);
        node->keys[idx] = succ;
        deleteKey(node->children[idx + 1], succ);
    } else {
        merge(node, idx);
        deleteKey(node->children[idx], key);
    }
}

この関数は、キーが内部ノードにある場合の処理を行います。必要に応じて、前任者（predecessor）や後継者（successor）と置き換えたり、ノードをマージします。

その他の補助関数

その他の補助関数として、前任者と後継者を取得する関数、ノードをマージする関数、ノードを埋める（fill）関数などがあります。

int getPredecessor(BTreeNode* node, int idx) {
    BTreeNode* cur = node->children[idx];
    while (!cur->isLeaf) {
        cur = cur->children[cur->numKeys];
    }
    return cur->keys[cur->numKeys - 1];
}

int getSuccessor(BTreeNode* node, int idx) {
    BTreeNode* cur = node->children[idx + 1];
    while (!cur->isLeaf) {
        cur = cur->children[0];
    }
    return cur->keys[0];
}

void merge(BTreeNode* node, int idx) {
    BTreeNode* child = node->children[idx];
    BTreeNode* sibling = node->children[idx + 1];

    child->keys[T - 1] = node->keys[idx];

    for (int i = 0; i < sibling->numKeys; ++i) {
        child->keys[i + T] = sibling->keys[i];
    }

    if (!child->isLeaf) {
        for (int i = 0; i <= sibling->numKeys; ++i) {
            child->children[i + T] = sibling->children[i];
        }
    }

    for (int i = idx + 1; i < node->numKeys; ++i) {
        node->keys[i - 1] = node->keys[i];
    }

    for (int i = idx + 2; i <= node->numKeys; ++i) {
        node->children[i - 1] = node->children[i];
    }

    child->numKeys += sibling->numKeys + 1;
    node->numKeys--;

    free(sibling);
}

void fill(BTreeNode* node, int idx) {
    if (idx != 0 && node->children[idx - 1]->numKeys >= T) {
        borrowFromPrev(node, idx);
    } else if (idx != node->numKeys && node->children[idx + 1]->numKeys >= T) {
        borrowFromNext(node, idx);
    } else {
        if (idx != node->numKeys) {
            merge(node, idx);
        } else {
            merge(node, idx - 1);
        }
    }
}

これらの関数により、B木の削除操作を行う際に必要な再構成が可能になります。

以上で、B木からノードを削除するための具体的なアルゴリズムとその実装方法について説明しました。次のセクションでは、B木での検索操作について詳しく説明します。

B木の検索操作

B木での検索操作は、効率的にデータを見つけるための基本的な操作です。ここでは、B木でキーを検索するアルゴリズムとその実装方法について詳しく説明します。

検索操作の概要

B木での検索は、各ノードのキーを順番に比較し、該当する子ノードへ再帰的に進むことで行います。この操作は、ノードの高さが低く保たれているため、最大でもO(log n)の時間で完了します。

検索操作のアルゴリズム

B木のノード内のキーを順番に調べ、該当するキーを見つけた場合はその位置を返し、見つからない場合は適切な子ノードに再帰的に移動します。以下に、検索操作の関数の実装を示します。

BTreeNode* search(BTreeNode* node, int key) {
    int i = 0;
    while (i < node->numKeys && key > node->keys[i]) {
        i++;
    }

    if (i < node->numKeys && key == node->keys[i]) {
        return node;
    }

    if (node->isLeaf) {
        return NULL;
    }

    return search(node->children[i], key);
}

この関数では、まずノード内のキーを順番に比較し、キーが見つかった場合はそのノードを返します。キーが見つからなかった場合、葉ノードであればNULLを返し、内部ノードであれば該当する子ノードに再帰的に移動します。

検索操作の例

以下は、具体的なB木とその検索操作の例です。

int main() {
    BTreeNode* root = createNode(true);

    insert(&root, 10);
    insert(&root, 20);
    insert(&root, 5);
    insert(&root, 6);
    insert(&root, 12);
    insert(&root, 30);
    insert(&root, 7);
    insert(&root, 17);

    BTreeNode* result = search(root, 6);
    if (result != NULL) {
        printf("Key 6 found in B-Tree.\n");
    } else {
        printf("Key 6 not found in B-Tree.\n");
    }

    return 0;
}

この例では、いくつかのキーをB木に挿入し、キー6を検索しています。キーが見つかった場合は「Key 6 found in B-Tree.」、見つからなかった場合は「Key 6 not found in B-Tree.」と出力されます。

効率的な検索の理由

B木の検索操作が効率的である理由は、各ノードが複数のキーを保持し、すべての子ノードがバランスよく配置されているためです。これにより、ツリーの高さが低く保たれ、検索パスが短くなります。

以上で、B木での検索操作について説明しました。次のセクションでは、B木の構造を視覚的に理解するための可視化方法について説明します。

B木の可視化

B木の構造を視覚的に理解することは、データの管理やアルゴリズムの理解を深めるために非常に有用です。ここでは、B木を可視化する方法について説明します。

可視化の必要性

B木は複雑なデータ構造であり、ノードの挿入、削除、検索の各操作がどのように行われるかを視覚的に確認することで、アルゴリズムの動作をより直感的に理解できます。特に、B木がどのようにバランスを保つかを視覚的に示すことは重要です。

可視化ツールの利用

プログラム内でB木を可視化するためには、グラフ描画ツールを使用する方法があります。ここでは、一般的なツールであるGraphvizを使用した例を紹介します。

Graphvizのインストール

Graphvizは、オープンソースのグラフ描画ツールで、B木のようなデータ構造を視覚的に表現するのに適しています。まず、Graphvizをインストールします。

# Linuxの場合
sudo apt-get install graphviz

# macOSの場合
brew install graphviz

Graphviz用のdotファイル生成

次に、B木の構造を表現するdotファイルを生成するための関数を作成します。

#include <stdio.h>

void generateDotFile(BTreeNode* root, FILE* file) {
    fprintf(file, "digraph BTree {\n");
    fprintf(file, "node [shape=record];\n");
    generateDotNode(root, file);
    fprintf(file, "}\n");
}

void generateDotNode(BTreeNode* node, FILE* file) {
    fprintf(file, "node%p [label=\"", (void*)node);
    for (int i = 0; i < node->numKeys; i++) {
        fprintf(file, "<f%d> | %d |", i, node->keys[i]);
    }
    fprintf(file, "<f%d>\"];\n", node->numKeys);

    if (!node->isLeaf) {
        for (int i = 0; i <= node->numKeys; i++) {
            if (node->children[i] != NULL) {
                fprintf(file, "node%p:<f%d> -> node%p;\n", (void*)node, i, (void*)node->children[i]);
                generateDotNode(node->children[i], file);
            }
        }
    }
}

この関数は、B木の構造をdotファイル形式で出力します。

dotファイルの生成と可視化

B木を挿入した後、dotファイルを生成してGraphvizで可視化します。

int main() {
    BTreeNode* root = createNode(true);

    insert(&root, 10);
    insert(&root, 20);
    insert(&root, 5);
    insert(&root, 6);
    insert(&root, 12);
    insert(&root, 30);
    insert(&root, 7);
    insert(&root, 17);

    FILE* file = fopen("btree.dot", "w");
    if (file != NULL) {
        generateDotFile(root, file);
        fclose(file);
    }

    // システムコマンドでdotファイルを画像に変換
    system("dot -Tpng btree.dot -o btree.png");

    return 0;
}

この例では、B木にいくつかのキーを挿入し、btree.dotというファイルにB木の構造を出力します。その後、dotコマンドを使用してdotファイルをPNG画像に変換します。

可視化結果の確認

生成された画像ファイルbtree.pngを確認することで、B木の構造を視覚的に理解できます。これにより、各操作がB木に与える影響を直感的に把握することができます。

以上で、B木の可視化方法について説明しました。次のセクションでは、B木の応用例と実装演習について紹介します。

応用例と実装演習

B木の理論と基本的な操作を学んだ後は、応用例を通じて実際の使用方法を理解し、さらに実装演習を行うことで、より深く理解を深めましょう。

応用例

B木は、データベースやファイルシステムなどの分野で広く利用されています。ここでは、いくつかの具体的な応用例を紹介します。

データベース管理システム（DBMS）

多くのデータベース管理システムでは、インデックスの実装にB木が使用されています。インデックスを用いることで、大量のデータから特定のレコードを高速に検索、挿入、削除することが可能です。

// 簡単なB木インデックスの例
typedef struct {
    int key;
    int recordID; // データベース内のレコードID
} IndexEntry;

void insertIndex(BTreeNode** root, IndexEntry entry) {
    insert(root, entry.key);
    // 実際のDBMSでは、キーとレコードIDのマッピングも管理する
}

ファイルシステム

B木は、ファイルシステムにおけるディレクトリの管理にも使用されます。例えば、NTFSファイルシステムでは、B+木を使用してディレクトリ内のファイル名を管理しています。

// 簡単なファイルシステムのディレクトリ管理例
typedef struct {
    char fileName[256];
    int fileID; // ファイルシステム内のファイルID
} DirectoryEntry;

void insertDirectory(BTreeNode** root, DirectoryEntry entry) {
    insert(root, entry.fileID);
    // 実際のファイルシステムでは、ファイル名とファイルIDのマッピングも管理する
}

メモリ管理

B木は、メモリ管理やキャッシュ管理にも利用されます。例えば、OSのメモリ管理では、ヒープ領域の管理にB木が使用されることがあります。

// 簡単なメモリ管理の例
typedef struct {
    int address;
    int size;
} MemoryBlock;

void insertMemoryBlock(BTreeNode** root, MemoryBlock block) {
    insert(root, block.address);
    // 実際のメモリ管理では、アドレスとサイズのマッピングも管理する
}

実装演習

ここでは、B木の理解を深めるための実装演習を提供します。

演習1：B木の全巡回

B木のすべてのノードを巡回して、キーを順に出力する関数を実装してください。

void traverse(BTreeNode* root) {
    if (root != NULL) {
        int i;
        for (i = 0; i < root->numKeys; i++) {
            if (!root->isLeaf) {
                traverse(root->children[i]);
            }
            printf("%d ", root->keys[i]);
        }
        if (!root->isLeaf) {
            traverse(root->children[i]);
        }
    }
}

演習2：B木の深さを計算する

B木の深さを計算する関数を実装してください。

int getDepth(BTreeNode* root) {
    int depth = 0;
    BTreeNode* current = root;
    while (current != NULL && !current->isLeaf) {
        depth++;
        current = current->children[0];
    }
    return depth;
}

演習3：キーの範囲検索

特定の範囲内のキーをすべて検索する関数を実装してください。

void rangeSearch(BTreeNode* root, int minKey, int maxKey) {
    if (root != NULL) {
        int i = 0;
        while (i < root->numKeys && root->keys[i] < minKey) {
            i++;
        }
        while (i < root->numKeys && root->keys[i] <= maxKey) {
            if (!root->isLeaf) {
                rangeSearch(root->children[i], minKey, maxKey);
            }
            printf("%d ", root->keys[i]);
            i++;
        }
        if (!root->isLeaf) {
            rangeSearch(root->children[i], minKey, maxKey);
        }
    }
}

これらの演習を通じて、B木の操作に慣れ親しみ、理解を深めることができるでしょう。

以上で、B木の応用例と実装演習について説明しました。次のセクションでは、本記事のまとめを行います。

まとめ

本記事では、B木の基本概念から具体的なC言語での実装方法までを詳細に解説しました。B木は、多くの応用分野で使用される効率的なデータ構造であり、その操作は検索、挿入、削除、可視化、応用例、実装演習にわたります。B木の理解を深めるために、実際に手を動かしてコードを実装し、演習問題を解くことをお勧めします。この記事を通じて、B木の基本から応用までをマスターし、実際のプロジェクトで活用できるようになることを期待しています。

C言語
プログラミング 実装ガイド データ構造 アルゴリズム C言語 B木

コメント

コメントする

目次