#include<iostream>
using namespace std;

#ifndef __BTREE_H__
#define __BTREE_H__

template<class K,int M=3>//设为三阶B树（每个数组三个关键字）
struct BNode
{
	BNode<K,M>* _parent;
	size_t _size;//元素个数
	K keys[M];//由于subs多了一个长度
	BNode<K,M> *subs[M+1];//为了使插入元素分裂时先讲该数放进数组中再调整而又不越界
	BNode()
		:_parent(NULL)
		,_size(0)
	{
		for (int i = 0; i <= M + 1; i++)
		{
			subs[i] = NULL;//指针数组每个元素都为空指针,key不初始化,sub初始化为空指针
		}
	}
};

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


template<class K,int M=3>
class BTree
{
	typedef BNode<K,M> Node;
public:
	BTree()
		:_root(NULL)
	{}


	Pair<Node*,int> Find(const K& key)
	{
		if (_root == NULL)
			return Pair<Node*,int>(NULL,-1);
		//思路：根据元素的大小以及遍历每个数组的关键字判断要走哪一条支路，再逐层逐层查找
		Node* cur = _root;
		Node* parent = NULL;
		while (cur)
		{
			int index = 0;
			while (index < cur->_size)
			{
				if (cur->keys[index] > key)
				{
					break;
				}
				else if (cur->keys[index] < key)
				{
					index++;
				}
				else
				{
					return Pair<Node*, int>(parent, index);
				}
			}
			parent = cur;
			cur = cur->subs[index];
		}
		return Pair<Node*, int>(parent, -1);
		//找完也没找到,为了使得该情况下方便插入节点，因此返回parent,插入节点插在parent上
	}


	bool Insert(const K& key)
	{
		//思路：若无结点，插入根节点；若有节点，找到合适位置插入在根节点上，如果此时插上该节点后
		//元素个数_size=M,则分裂，向上调整中位数，若调整后仍然是这样，则继续调整，直到不满足。
		if (_root == NULL)
		{
			_root = new Node;
			_root->keys[0] = key;
			_root->subs[0] = NULL;
			_root->_parent = NULL;
			_root->_size++;
			return true;
		}
		//若有该节点了，则不插入重复节点！！！
		if (Find(key)._second != -1)//不重复
		{
			return false;
		}
		Node* cur = Find(key)._first;//!!!根据查找到的位置直接插，避免代码冗余
		Node* sub = NULL;
		int insertKey = key;
		while (1)
		{
			_Insert(cur, sub, insertKey);//先将该元素key插入，放在该数组的合适位置
			if (cur->_size < M)//插入后，无需分裂
			{
				return true;
			}
			//需要分裂		
			int index = 0;
			Node* tmp = new Node;
			int mid = (cur->_size-1) / 2;
			//拷贝key值
			for (int i = mid + 1; i < cur->_size; i++)
			{
				tmp->keys[index++] = cur->keys[i];
				tmp->_size++;
			}
			//拷贝关键字的下标
			for (int i = mid + 1; i <= cur->_size; i++)
			{
				tmp->subs[index++] = cur->subs[i];
				if (cur->subs[i])//有子链，链上
				{
					cur->subs[i]->_parent = tmp;
				}
			}
			cur->_size = (cur->_size - 1) / 2;//更新cur数组元素个数
			if (cur->_parent == NULL)
			{
				//分两条支路，左支路为cur,右支路为tmp链上
				_root = new Node;
				_root->keys[0] = cur->keys[mid];
				_root->subs[0] = cur;
				_root->subs[1] = tmp;
				_root->_size++;
				cur->_parent = _root;
				tmp->_parent = _root;
				return true;
			}
			else
			{			
				insertKey = cur->keys[mid];//该插入mid位置元素
				sub = tmp;//子串便成为tmp
				cur = cur->_parent;//继续调整
			}
		}
		
	}


protected:
	void _Insert(Node* cur, Node* sub,const K& key)
	{
		size_t index = cur->_size;
		while (index >= 0 && cur->keys[index]>key)//为便于key查到合适位置，先将元素往后移动1个长度到合适位置
		{
			cur->keys[index+1] = cur->keys[index];
			cur->subs[index + 1] = cur->subs[index];//下标也要更新
			index--;
		}	
		cur->keys[index+1] = key;
		cur->subs[index + 2] = sub;
		if (sub)
		{
			sub->_parent = cur;
		}
		cur->_size++;
	}
private:
	Node* _root;
};
#endif //__BTREE_H__

测试代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include "BTree.h"

void BTreeTest()
{
	BTree<int,3> btree;
	int a[] = { 53, 75, 139, 49, 145, 36, 101 };
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		btree.Insert(a[i]);
	}
	btree.Find(5);
}
int main()
{
	BTreeTest();
	system("pause");
	return 0;
}