平衡搜索树(三) B-Tree
B树的简介
B 树是为了磁盘或其它存储设备而设计的一种多叉平衡查找树。与红黑树很相似,但在降低磁盘I/0操作方面要更好一些(树的深度较低)。许多数据库系统都一般使用B树或者B树的各种变形结构。
B树与红黑树最大的不同在于,B树的结点可以有许多子女,从几个到几千个。那为什么又说B树与红黑树很相似呢?因为与红黑树一样,一棵含n个结点的B树的高度也为O(lgn),但可能比一棵红黑树的高度小许多,应为它的分支因子比较大。所以,B树可以在O(logn)时间内,实现各种如插入(insert),删除(delete)等动态集合操作。
如下图所示,即是一棵B树,现在要从树种查找字母R(包含x个关键字的内结点,x+1 个子女。所有的叶结点都处于相同的深度,带阴影的结点为查找字母R时要检查的结点):
非叶子结点最多子树个数也称为阶数,一棵M阶(M>2)的B树,是一棵平衡的M路平衡搜索树,满足一下性质:
1. 根节点至少有两个孩子
2. 每个非根节点有[M/2 ,M]个孩子;(M/2取上整)
3. 每个非根节点有[ M/2-1,M-1]个关键字,并且以升序排列。(M/2取上整)
4. key[i]和key[i+1]之间的孩子节点的值介于key[i]、key[i+1]之间
5. 所有的叶子节点都在同一层
现在你是不是对B—Tree树有了一个大体的认识了?如果还是一头雾水也没关系,相信看完后面的内容你会对B-Tree有所了解 O(∩_∩)O
OK现在我们一起来实现一下这个 B-Tree ......
该怎样实现这个B树呢,它的节点需要什么属性呢~~这是我们要思考的问题:
首先,节点中得有这个树的阶数(孩子节点的指针最多的个数)吧!好的那咱们定义一个M来做为你这个B树的阶数
然后呢,我们是不是得需要一个保存关键字的数组,和一个保存你需要保存关键字对应的信息的数组。比如说:我需要根据一个人的身证号来获取他的个人信息,这个身份证号就是关键字,个人信息就是我们经过检索想要得到的信息; 好的,我们现在就在节点中建立一个 _keys[M],_values[M] 哎哎.... 有的小伙伴会说一个节点最多有 M-1(阶数-1)个关键字么,你怎么数组长度定义为M 你憋着急。。后面你就知道它的好处了;
还有什么呢?没错应该是你这个节点中真实保存的关键字的数目,来确定是不是超出规定的阶数减一个了;
接下来,节点中是不是有一个指向孩纸节点的指针数组啊!对 那咱们在结构体中定义一个 Node* _subs[M+1]
还有撒子嘞,哦哦咱们还需要一个指向父亲节点的指针,供回溯时使用。 Node* _parent;
一切就绪 Load。。。
1 template<class K,class V,int M = 3> 2 struct BTreeNode 3 { 4 typedef BTreeNode<K, V, M> Node; 5 BTreeNode() 6 :_size(0), _parent(NULL) 7 { 8 for (int i = 0; i < M + 1; ++i) 9 { 10 _subs[i] = NULL; 11 } 12 } 13 K _keys[M]; //关键字数组 14 V _values[M]; //信息数组 15 Node* _subs[M + 1]; //指向孩子节点的指针数组 16 size_t _size; //关键字的个数 17 Node* _parent; //指向父亲点的指针 18 };
节点创建好之后呢,我们来创建这个B-Tree
1 template<class K,class V> //实现返回两种类型的变量 2 struct Pair 3 { 4 K _first; 5 V _second; 6 7 Pair(const K& key = K(), const V& value = V()) 8 :_first(key), _second(value) 9 {} 10 }; 11 12 13 template<class K,class V,int M = 3> 14 class BTree 15 { 16 typedef BTreeNode<K, V, M> Node; 17 public: 18 BTree() 19 :_root(NULL) 20 {} 21 public: 22 Pair<Node*, bool> _Find(const K& key); //查找(返回值是一个指向B-Tree节点的指针,和是否找到 true/false) 23 bool _Insert(const K& key, const V& value,Node* sub = NULL); //插入 24 void _Order() { Order(_root); }; //中序遍历 25 void Order(Node* root); 26 27 protected: 28 Node* _root; 29 };
你没有看错,基本的 B—Tree 结构实现起来就是这麽个样子!现在就让我们来探究一下这背后的玄机....
1 template<class K, class V, int M = 3> 2 Pair<BTreeNode<K,V,M>*, bool> BTree<K, V, M>::_Find(const K& key) 3 { 4 Node* parent = NULL; 5 Node* cur = _root; 6 if (cur == NULL) 7 { 8 return Pair<Node*, bool>(cur, false); 9 } 10 else 11 { 12 while (cur) 13 { 14 int i = 0; 15 for (; (key > cur->_keys[i]) && (i < cur->_size); ++i); 16 if (key == cur->_keys[i]) //找到相应的值了 17 { 18 return Pair<Node*, bool>(cur, true); 19 } 20 else 21 { 22 parent = cur; 23 cur = cur->_subs[i]; 24 } 25 } 26 return Pair<Node*, bool>(parent, false); 27 } 28 }
查找函数到底是一个什么样的机制呢,这幅图能使你更清楚一些:
![](https://images2015.cnblogs.com/blog/945368/201604/945368-20160429234610878-2025709739.png)
//B-Tree 的插入函数
1 template<class K, class V, int M = 3>
2 bool BTree<K, V, M>::_Insert(const K& key, const V& value,BTreeNode<K, V, M>* sub = NULL) 3 { 4 if (_root == NULL) //如果根节点为空 5 { 6 _root = new Node; 7 _root->_keys[0] = key; 8 _root->_values[0] = value; 9 _root->_size++; 10 } 11 else //根节点不为空 12 { 13 Pair<Node*, bool> exist = _Find(key); 14 if (exist._second) //如果该关键字已经存在 15 { 16 cout << "This Key already exists!" << endl; 17 return false; 18 } 19 else //B树中还没有此关键字,此时应该插入相应信息 20 { 21 Node* cur = exist._first; 22 Node* before = NULL; 23 Node* tmp = sub; 24 K middlekey = key; 25 V middlevalue = value; 26 while (1) 27 { 28 //第一次分裂完成之后_keys[middle] 要往父亲节点中插入, 29 //父亲节点可能为空 30 if (cur == NULL) 31 { 32 Node* parent = new Node(); 33 parent->_keys[0] = middlekey; 34 parent->_values[0] = middlevalue; 35 ++parent->_size; 36 parent->_subs[0] = before; 37 before->_parent = parent; 38 parent->_subs[1] = tmp; 39 tmp->_parent = parent; 40 _root = parent; 41 return true; 42 } 43 int index = _BinarySearch<K>(cur->_keys, cur->_size, key); 44 for (int i = cur->_size; i > index; --i) 45 { 46 cur->_keys[i] = cur->_keys[i - 1]; //将关键字后移 47 cur->_values[i] = cur->_values[i - 1]; //将关键字对应的有效信息后移 48 cur->_subs[i + 1] = cur->_subs[i]; //指向孩子节点的指针后移 49 }
50 cur->_keys[index] = middlekey; //移动好之后将相应的数据更新 51 cur->_values[index] = middlevalue; 52 cur->_subs[index+1] = tmp; //tmp是分裂出来的新节点 53 if (tmp) 54 { 55 tmp->_parent = cur; 56 } 57 ++cur->_size; 58 59 if (cur->_size < M) //关键字的个数合法 60 { 61 return true; 62 } 63 else //关键字的个数非法(M个关键字) 64 { 65 int middle = M / 2; 66 int position = 0; 67 int size = cur->_size; 68 Node* _tmp = new Node(); 69 70 for (int i = middle + 1; i <= cur->_size; ++i) //将右半边分裂出去(_tmp) 71 { 72 _tmp->_keys[position] = cur->_keys[i]; 73 _tmp->_values[position] = cur->_values[i]; 74 _tmp->_subs[position] = cur->_subs[i]; 75 --cur->_size; 76 ++_tmp->_size; 77 } 78 _tmp->_subs[_tmp->_size] = cur->_subs[size];
80 middlekey = cur->_keys[middle]; //往上插入的关键字 81 middlevalue = cur->_values[middle]; 82 --cur->_size; 83 84 before = cur; 85 cur = cur->_parent; 86 tmp = _tmp; 87 } 88 } 89 } 90 } 91 } 92
//插入的过程图解
94 95 template<class K> 96 int _BinarySearch(const K* keys, int size,const K& key) 97 { 98 assert(keys); 99 int low = 0; 100 int high = size - 1; 101 while (low < high) 102 { 103 int middle = (high - low) / 2 + low; 104 key > keys[middle] ? (low = middle + 1) : (high = middle - 1); 105 } 106 return (key > keys[low] ? low + 1 : low); 107 }
//中序遍历
1 template<class K, class V, int M = 3> 2 void BTree<K, V, M>::Order(Node* root) 3 { 4 if (root == NULL) 5 { 6 return; 7 } 8 else 9 { 10 for (int i = 0; i < root->_size; ++i) 11 { 12 Order(root->_subs[i]); 13 cout << "[" << root->_keys[i] << "]" << " :" << root->_values[i] << endl; 14 } 15 Order(root->_subs[root->_size]); 16 } 17 }
//测试用例
void Test() { BTree<int, string> btree; btree._Insert(53, "数据结构"); btree._Insert(75,"Linux"); btree._Insert(139,"算法导论"); btree._Insert(49,"剑指offer"); btree._Insert(145,"c++ Primer"); btree._Insert(36,"操作系统"); btree._Insert(101, "计算机原理"); /*中序遍历*/ btree._Order(); }
//此为中序遍历的结果
到这里呢,这个B-Tree的构建就基本完成了,如果小伙伴们还有什么更好的方法,或者说是对这篇博文有什么意见或者建议什么的欢迎参与评论,跪求赐教~~