c++实现Bー树

实现一个完整的B-树是一个相当复杂的任务，需要考虑节点的分裂、合并、插入、删除等操作，并保持树的平衡性。下面是一个简单的B-树的部分实现，包括节点的定义、插入操作和中序遍历：

#include <iostream>
#include <vector>
#include <algorithm>

// B-树节点
template<typename T>
struct BTreeNode {
    std::vector<T> keys;
    std::vector<BTreeNode<T>*> children;
    bool leaf;

    BTreeNode(bool isLeaf) : leaf(isLeaf) {}
};

// B-树
template<typename T>
class BTree {
private:
    BTreeNode<T>* root;
    int degree;

    void splitChild(BTreeNode<T>* parent, int index, BTreeNode<T>* child) {
        BTreeNode<T>* newNode = new BTreeNode<T>(child->leaf);
        newNode->keys.assign(child->keys.begin() + degree, child->keys.end());
        child->keys.erase(child->keys.begin() + degree, child->keys.end());

        if (!child->leaf) {
            newNode->children.assign(child->children.begin() + degree, child->children.end());
            child->children.erase(child->children.begin() + degree, child->children.end());
        }

        parent->keys.insert(parent->keys.begin() + index, child->keys[degree - 1]);
        parent->children.insert(parent->children.begin() + index + 1, newNode);
    }

    void insertNonFull(BTreeNode<T>* node, T key) {
        int i = node->keys.size() - 1;
        if (node->leaf) {
            while (i >= 0 && key < node->keys[i]) {
                node->keys[i + 1] = node->keys[i];
                i--;
            }
            node->keys[i + 1] = key;
        } else {
            while (i >= 0 && key < node->keys[i]) {
                i--;
            }
            i++;
            if (node->children[i]->keys.size() == 2 * degree - 1) {
                splitChild(node, i, node->children[i]);
                if (key > node->keys[i]) {
                    i++;
                }
            }
            insertNonFull(node->children[i], key);
        }
    }

public:
    BTree(int deg) : root(nullptr), degree(deg) {}

    void insert(T key) {
        if (!root) {
            root = new BTreeNode<T>(true);
            root->keys.push_back(key);
        } else {
            if (root->keys.size() == 2 * degree - 1) {
                BTreeNode<T>* newRoot = new BTreeNode<T>(false);
                newRoot->children.push_back(root);
                splitChild(newRoot, 0, root);
                root = newRoot;
            }
            insertNonFull(root, key);
        }
    }

    void inorderTraversal(BTreeNode<T>* node) {
        if (node) {
            int i;
            for (i = 0; i < node->keys.size(); i++) {
                if (!node->leaf) {
                    inorderTraversal(node->children[i]);
                }
                std::cout << " " << node->keys[i];
            }
            if (!node->leaf) {
                inorderTraversal(node->children[i]);
            }
        }
    }

    void printInorder() {
        inorderTraversal(root);
    }
};

int main() {
    BTree<int> btree(3);

    btree.insert(1);
    btree.insert(3);
    btree.insert(7);
    btree.insert(10);
    btree.insert(11);
    btree.insert(13);
    btree.insert(14);
    btree.insert(15);
    btree.insert(18);
    btree.insert(16);
    btree.insert(19);
    btree.insert(24);
    btree.insert(25);
    btree.insert(26);
    btree.insert(21);
    btree.insert(4);
    btree.insert(5);
    btree.insert(20);
    btree.insert(22);
    btree.insert(2);
    btree.insert(17);
    btree.insert(12);
    btree.insert(6);

    std::cout << "Inorder traversal of the B-tree is: ";
    btree.printInorder();
    std::cout << std::endl;

    return 0;
}

这个示例演示了一个简单的B-树实现，包括插入操作和中序遍历。由于B-树的复杂性，这个实现仅包含了部分功能，并且可能不适用于所有情况。