B树

#include<iostream>
using namespace std;
template<class K,int M=3>
struct BTreeNode
{
    K _keys[M];
    BTreeNode<K, M>* _subs[M+1];
    size_t size;
    BTreeNode<K, M>* _parent;
    BTreeNode() :size(0), _parent(NULL)
    {
        for (size_t i = 0 ; i < M + 1; ++i)
        {
            _subs[i] = NULL;
        }
    }
};

template<class K, class V>
struct Pair
{
    K _first;
    V _second;
    Pair(const K&k = K(), const V&v = V())
        :_first(k), _second(v)
    {}
};

template<class K,int M=3>
class BTree
{
    typedef BTreeNode<K, M> Node;
public:
    BTree() :_root(NULL)
    {}
    Pair<Node*, int> Find(const K&key)
    {
        Node* parent = NULL;
        Node* cur = _root;
        while (cur)
        {
            int i = 0;
            while (i<cur->size&&cur->_keys[i]<key)
            {
                ++i;
            }
            if (cur->_keys[i] == key)
            {
                return Pair<Node*, int>(cur, i);
            }
            parent = cur;
            cur = cur->_subs[i];
        }
        return Pair<Node*, int>(parent, -1);
    }

    bool Insert(const K&key)
    {
        if (_root == NULL)
        {
            _root = new Node;
            _root->_keys[0] = key;
            ++_root->size;
            return true;
        }

        Pair<Node*, int> ret = Find(key);
        if (ret._second != -1)
        {
            return false;
        }

        K k = key;
        Node* cur = ret._first;
        Node* sub = NULL;
        _InsertKey(cur, k, sub);
        while (1)
        {
            if (cur->size < M)
            {
                return true;
            }
            int boundary = M / 2;
            k = cur->_keys[boundary];
            Node *tmp = new Node;
            size_t size = cur->size;
            size_t index = 0;
            for (int i = boundary + 1; i < size; ++i)
            {
                tmp->_keys[index++] = cur->_keys[i];
                tmp->size++;
                cur->size--;
            }


            index = 0;
            for (int i = boundary + 1; i <= size; ++i)
            {
                tmp->_subs[index] = cur->_subs[i];
                if (tmp->_subs[index])
                {
                    tmp->_subs[index]->_parent = tmp;
                }
                ++index;
            }

            K k = cur->_keys[boundary];
            cur->size--;
            if (cur->_parent == NULL)
            {
                _root = new Node;
                _root->_keys[0] = k;
                _root->_subs[0] = cur;
                _root->_subs[1] = tmp;
                _root->size = 1;
                tmp->_parent = _root;
                cur->_parent = _root;
                return true;
            }
            else
            {    
                    cur= cur->_parent;
                    _InsertKey(cur, k, sub);
                    ret = Find(k);
                    int i = ret._second + 1;
                    cur->_subs[i] = tmp;
                    tmp->_parent = cur;                    
            }
        }
    }

    void Inorder()
    {
        _Inorder(_root);
        cout << endl;
    }

    void _Inorder(Node* root)
    {
        if (root == NULL)
        {
            return;
        }
        for (size_t i = 0; i < root->size; ++i)
        {
            _Inorder(root->_subs[i]);
            cout << root->_keys[i] << " ";
        }
        _Inorder(root->_subs[root->size]);
    }

    void _InsertKey(Node* cur, const K&k, Node* sub)
    {
        int i = cur->size - 1;
        while (i>=0)
        {
            if (cur->_keys[i] > k)
            {
                cur->_keys[i + 1] = cur->_keys[i];
                cur->_subs[i + 2] = cur->_subs[i+1];
                --i;
            }
            else
            {
                break;
            }
        }
        cur->_keys[i + 1] = k;
        cur->_subs[i + 2] = sub;
        if (sub)
        {
            sub->_parent = cur;
        }
        cur->size++;
    }
protected:
    Node* _root;
};
void TestBTree()
{
    BTree<int> t;
    int a[] = { 53, 75, 139, 49, 145, 36, 10 };
    for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        t.Insert(a[i]);
    }
    t.Inorder();
}
void TestBTree1()
{
    BTree<int> t1;
    int a[] = { 63, 75, 139, 49, 36, 10, 65, 78, 99,132,28,76,156,198};
    for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        t1.Insert(a[i]);
    }
    t1.Inorder();
}

int main()
{
    TestBTree1();
    system("pause");
    return 0;
}