B -树索引的建立

数据库系统实现

实验报告

实验名称： B -树索引的建立

一、实验内容

使用B-树对数据库进行索引。按照学生ID建立起B树索引。实验需要建立两个文本文件：数据文件datafile.txt和命令文件command.txt。数据文件包含了所有需要建立检索的学生信息，文本中的每一行包含一个学生的信息。每一行将由6个空格分隔的字符段组成：ID （9位），姓（最多15个字符），名（最多

15个字符），年级（1位），专业（最多4个字符），以及邮箱地址（最多20个字符）。

二、实验分析：

三、步骤分析及流程图

步骤分析：一个具有10,000,000个记录的文本文件共计10,000,000*100B=1000MB,而内存只有50MB，50MB/4KB=50*1024 KB/4KB=12800块，每块可以存放4*1024B/100B=40个记录，每块剩余96KB，内存一共可以存放12800*40=512000个记录，一共有10,000,000个记录。

所以要进行10,000,000/512000=19.53次，即20次排序，每次排序的记录数为10,000,000/20=500,000个记录。

因此此次实验需要将文本文件分成20个子文件。分别对子文件分别进行内部排序。最后对20个排好序的子文件进行归并排序，完成排序。

故将其分为三个阶段

1.生成一个具有10,000,000个记录的文本文件data.txt，其中每个记

录由100个字节组成，其中只有一个整数类型属性A，剩余字节用0

填充。程序生成一个4个字节之内随机整数作为每条记录的属性，

剩余字节用0填充。记录写入data.txt文件中。

2.根据实验分析，将data.txt文件分为20个子文件，并且按照文件

中每个记录的属性对各个子文件进行内部排序，最终形成20个有序

的子文件data1.txt,data2,txt,…data20.txt。

3.对20个有序的子文件进行归并排序，最终形成一个有序的结果文件

result.txt。

流程图：

阶段一流程图见图1.1

图1.1 随机生成10,000,000个记录的文件流程图阶段二流程图见图1.2

图1.2 分离出20个内部有序的子文件流程图

阶段三流程图见图1.3

图1.3 将20个有序的子文件进行归并排序的流程图

四、算法优化

开始在阶段二，我们小组是利用自己写在类JL里的函数sort，采用选择序方法，运行后发现因为数据量大，产生速度特别慢。后来尝试用了快速排序，但是上网查了之后，发现调用java里面原有的排序函数速度更快。

五、实验中遇到的问题及解决

问题：函数produceResult()中我在写路径的时候，不小心多写了”/.txt”

而这个是通过编译的，却导致阶段三长时间运行不出来，开始还以为算法出了问题。

解决：将路径正确书写。

六、实验结果及分析

1.生成一个具有10,000,000个记录的文本文件xyj.txt。

2.将data.txt文件分为20个子文件，并且按照文件中每个记录的属性对

各个子文件进行内部排序,最终形成20个有序的子文件data0.txt,data1.txt,…data19.txt。这个阶段所用时间为46秒。

3.对20个有序的子文件进行归并排序，最终形成一个有序的结果文件

result.txt。所用时间为40秒。

4.按照教材cylinder-based buffers(1M bytes)的方法，修改第二阶段的

算法所得结果：

而为改进前的结果为

可见，第二阶段排序所用时间为46秒，比上次时间的7分46秒明显缩短，跟我们预期的结果一致。

七、实验小结

这次实验是我第一次和他人合作一起做一个程序，感觉沟通交流还是非常重要的，还有要花时间去理解他人的想法，这些都让我收获良多。至于阶段三的归并排序，因为此前已经在数据结构中用C++实现过，即使不太擅长java语言，还是能较快的做出来。通过这次实验，我了解了数据库中的大量数据的读取并没有想象中那么简单，在数据量多的时候，一个好的算法的作用是很大的，也更好的理解了归并排序在大文件排序中的作用和性能。

代码部分

BTree.h文件

#include

#include

#include

#include

#include

using namespace std;

#define m 3 //B树的阶即一个节点有3个键值，4个指针

//学生类

class Student

{

public:

string StudentId; //学生ID （9位）

string StudentFirstName; //姓（最多15个字符）

string StudentLastName; //名（最多15个字符）

int grade; //年级

（1位）

string Major; //专业（最多4个字符）

string email; //邮箱地址

（最多20个字符）

int Id; //int型

的学生id，便于节点处理

Student(){} //空的

构造函数

Student(string id, string firstn, string lastn, int grade, string major, string mail); //构造函数

};

//node类即B树中的一个节点

class Node

{

public:

int num; //一个节点对应的键值个数

int key[m + 1]; //一个节点键值，之所以+1，便于后面节点分裂

Node * ptr[m + 1]; //一个节点的指针数

Node * parent; //指向父节点的指针

Node(); //默认构造函数让所有值为空

Node(int number, int k[]); //构造函数初始化一个节点，它的键值为数组k的值，键值个数为number个

bool isLeafNode(Node * node);//判断是否为叶子节点

};

//Result结构体用在查询函数上

struct Result

{

Node * nptr; //对应数据键值所在节点的指针

int position; //对应数据键值在节点中的位置，从0开始算

bool tag; //该键值是否在节点中

};

//B树类

class BTree

{

public:

Result search( int id); //查找学生id（键值）

void insert1(int id); //添加数据键值函数1，即情况1：叶节点未满，插入数据后不用分裂节点

void insert2(Result a, int id); //添加数据键值函数2，即情况2：叶节点满，插入数据后需要分裂叶节点，但是内层节点还有空间不需要分裂

void insert3(Node * cur, Node * b); //添加数据键值函数3，即情况3：在情况2的基础上，内层节点已满，也需要分裂

void deleteKey(int id); //删除数据的函数

void printTree(); //输出树

void initTree(); //默认的一颗树，这里用了ppt上的树BTree(); //默认的构造函数

private:

Node * root; //根节点

};

文件Btree.cpp

#include

#include

#include"BTree.h"

#include

#include

using namespace std;

/*===================================================================================== ==================*/

/*Student类中成员函数的具体实现*/

/*===================================================================================== ==================*/

//构造函数,初始化Student对象

Student::Student(string id, string firstn,string lastn, int grad, string major, string mail) {

StudentId = id;

StudentFirstName = firstn;

StudentLastName = lastn;

grade = grad;

Major = major;

email = mail;

Id = atoi(id.c_str()); //string 转int,需要include cstdlib

}

/*===================================================================================== ==================*/

/*Node类中成员函数的具体实现*/

/*===================================================================================== ==================*/

//默认构造函数所有值设为0或空

Node::Node()

{

num = 0;

key[0] = NULL;

key[1] = NULL;

key[2] = NULL;

key[3] = NULL;

ptr[0] = NULL;

ptr[1] = NULL;

ptr[2] = NULL;

ptr[3] = NULL;

}

//构造函数初始化一个节点，键值个数为number个，它的键值为数组k的值，

Node::Node(int number, int *k)

{

num = number;

for (int i = 0; i < number; i++)

key[i] = k[i];

ptr[0] = NULL;

ptr[1] = NULL;

ptr[2] = NULL;

ptr[3] = NULL;

}

//判断 node是不是叶子节点

bool Node::isLeafNode(Node * node)

{

Node* a = node->ptr[0];

if (a == NULL) //当节点的最左指针已经没指向任何值时该节点为叶子

return true;

else

return false;

}

/*===================================================================================== ==================*/

/*BTree类中成员函数的具体实现*/

/*===================================================================================== ==================*/

//构造函数初始化树

BTree::BTree()

{

initTree();

//root = NULL;

}

//默认的一颗树，这里用了ppt上的树

void BTree::initTree()

{

int n1[] = { 2, 3, 5 },

n2[] = { 7, 11 },

n3[] = { 13, 17, 19 },

n4[] = { 23, 29 },

n5[] = { 31, 37, 41 },

n6[] = { 43, 47 },

n7[] = { 7 },

n8[] = { 23, 31, 43 },

n9[] = { 13 };

Node *leaf1 = new Node(3, n1);

Node *leaf2 = new Node(2, n2);

Node *leaf3 = new Node(3, n3);

Node *leaf4 = new Node(2, n4);

Node *leaf5 = new Node(3, n5);

Node *leaf6 = new Node(2, n6);

Node *parent1 = new Node(1, n7);

Node *parent2 = new Node(3, n8);

Node *Troot = new Node(1, n9);

root = new Node(1, n9);

root->ptr[0] = parent1;

root->ptr[1] = parent2;

parent1->ptr[0] = leaf1;

parent1->ptr[1] = leaf2;

parent2->ptr[0] = leaf3;

parent2->ptr[1] = leaf4;

parent2->ptr[2] = leaf5;

parent2->ptr[3] = leaf6;

leaf1->parent = parent1;

leaf2->parent = parent1;

leaf3->parent = parent2;

leaf4->parent = parent2;

leaf5->parent = parent2;

leaf6->parent = parent2;

parent1->parent = root;

parent2->parent = root;

}

//查找学生id（键值）

Result BTree::search(int id)

{

Result r;

if (root == NULL) //如果根节点为空直接返回false结果

{

r.position = 0;

r. nptr = NULL;

r.tag = false;

return r;

}

else

{

Node * node = root;//从根节点开始查找向下搜索

int i;

while (!node->isLeafNode(node))

{

for (i = 0; i < node->num; i++)//遍历一个节点中有数据的键值

{

if (node->key[i] > id)//因为一个节点中的键值是从小到大排列的，当该键值大于id时，该id在该节点键值的对应的左部的指针指向的子树中

{

node = node->ptr[i];//到下一节点那查找

break;

}

if (i == node->num - 1)//当遍历到最后一个节点还没有结束，说明是在最大键值的右边的指针指向的子树

{

node = node->ptr[i + 1];//到下一节点那查找

break;

}

}

}

//在节点里寻找键值的位置

for (i = 0; i < node->num; i++)

{

if (node->key[i] == id)//找到该键值

{

r. nptr = node;

r.position = i;//i为该键值在节点中的位置，注：i从0开始记录

r.tag = true;

return r;//找到键值返回该结果

}

else if (node->key[i] > id) //如果键值不存在跳出循环注：若没找到，i定位就在稍大于要查找的键值对应的键的位置

break;

}

r. nptr = node;

r.position = i;//注：没找到，特殊情况：当键值大于节点中键值最大的那个值，i定位在最后那一个有数据的键值对应的位置，i是从0开始的

r.tag = false;//没找到，不存在该键值

return r; //这里不存在的情况也要记录位置是为了下面的函数插入的时候知道应插入的位置

}

}

/****************************************插入键值

*************************************************************/

void BTree::insert1(int id) //添加数据键值函数1，即情况1：叶节点未满，插入数据后不用分裂节点

{

Result re = search(id);

if (re.tag)

{

cout << "已存在该键值" << endl;

return;

}

else

{

if (re . nptr ->num == m) //要添加到的节点键值满了调用需要分裂的添加注：这里可能用m-1更好，代表对应的阶，前面的阶改成4

insert2(re , id);

else

{

/*没满直接在当前节点里添加数据因为叶节点只有两种情况要嘛2个键要嘛3个键

B树要求叶节点最后一个指针指向下一个叶节点，其他的n个指针至少要有

[(n+1)/2](向下取整)个指针被使用，

所以对应n=3（键值）的b树，至少要有2个指针被使用，即至少有两个键是要有数据的

在此情况下，叶节点就两种情况，2个键值，或三个键值，这里只考虑了节点最多只有三个键值的情况

*/

Node * cur = re.nptr ; //获取当前要插入的节点，Result re =search(id); 前面没有找到时，已经记录对应的node

int j;

/*注：可以用插入10来举例，key[3]即最后额外增加的那个空间，用来顺移，

要插入的位置是键值稍大于要插入键值的键值前面去，

将节点中对应要插入的位置对应的值开始依次向后复制，再插入对应的值

*/

for (j = re.position; j

cur->key[j + 1] = cur->key[j];

cur->key[re.position] = id;//插入键值

}

}

}

//更具体的添加当节点需要分裂时的添加

void BTree::insert2(Result re , int id)

{

Node * cur = re.nptr ; //获取当前要插入的节点

int j;

for (j = 3; j - re.position>0; j--)//j=re.position 时停止，即要插入键值之后的键值赋值后移已经完成

cur->key[j] = cur->key[j - 1];

cur->key[re . position ] = id; //先插入键值此时用到了key数组预留的一位值

int newkey[] = { cur->key[2], cur->key[3] };//取后面两个数据做成新节点

int value = cur->key[2];// value是要插入上一层的键值

cur->key[2] = NULL; cur->key[3] = NULL; //当前的后面两个数据清空cur->num = 2; //个数变化

Node * newnode = new Node(2, newkey);//新加入的节点注：新节点为较大的那两个键值组成的

newnode->parent = cur->parent; //指针变化

Node * parent1 = cur->parent;

//内层节点要求至少有(n+1)/2（向上取整）个指针被使用，这里的内层节点至少为两个指针，一个键值

//这里插入分三种情况，父节点有1个键值，有2个键值，有3个键值（满了，需要分裂节点）的情况

if (parent1->num == 1) //父节点没满且只有一个值

{

parent1->num++;

if (parent1->key[0] < value) //新值在右边添加的情况直接在右边补上值和指针

{

parent1->key[1] = value;

parent1->ptr[2] = newnode;

}

else//新的值在左边的话让原来的值右移一位

{

parent1->key[1] = parent1->key[0]; //右移一位

parent1->key[0] = value;

parent1->ptr[2] = parent1->ptr[1];

parent1->ptr[1] = newnode;

//ptr[0]仍然指向原来的那个键值较小的节点

}

}

//父节点没满且有两个值

else if (parent1->num == 2)//情况同上只是多分析一种

{

parent1->num++;

if (parent1->key[1] < value) //新值在右边添加的情况直接在右边补上值和指针

{

parent1->key[2] = value;

parent1->ptr[3] = newnode;

}

else if (parent1->key[0] < value) //在原来的两个值中插入

{

parent1->key[2] = parent1->key[1];

parent1->key[1] = value;

parent1->ptr[3] = parent1->ptr[2];

parent1->ptr[2] = newnode;

}

else//新值在左边添加的情况

{

parent1->key[2] = parent1->key[1];

parent1->key[1] = parent1->key[0];

parent1->key[0] = value;

parent1->ptr[3] = parent1->ptr[2];

parent1->ptr[2] = parent1->ptr[1];

parent1->ptr[1] = newnode;

}

}

else//父节点满了父节点也要分裂

{

insert3(parent1, newnode);

}

}

//添加数据键值函数3，即情况3：在情况2的基础上，内层节点已满，也需要分裂

void BTree::insert3(Node * cur, Node * b)

{

int i;

Node * parent1 = cur->parent;//内层节点的父节点，也就是根节点

if (parent1->num == 3) //根节点满了提示，没有再继续分根节点满了再分裂的情况{

cout << "树满了无法继续添加该值" << endl;

}

else

{

//让需要分裂的n节点的后两个值分裂出去称左边的为左父亲

int newkey[2] = { cur->key[1], cur->key[2] };

cur->num = 1;

Node * newnode = new Node(2, newkey);

newnode->parent = parent1;//新分出来的内层节点的父节点是根节点

//先获取原来的3个指针指向的节点

// Node * node1 = cur->ptr[0];

Node * node2 = cur->ptr[1];

Node * node3 = cur->ptr[2];

Node * node4 = cur->ptr[3];

int a1 = b->key[0], c[3] = { node2->key[0], node3->key[0], node4->key[0] };

/*a1是插入叶节点对应分出来的新节点的最小键值，c[3]是分裂内层节点前的后三个指针*/

for (i = 0; i < 3; i++)

{

if (a1 < c[i])

break;

}

//以上方法是为了知道分裂出来的叶节点在所有5个子节点中的位置但是该位置必定不会是第一个，所以4种情况

//注：为什么不会是第一个，因为上面分裂叶节点时总是将新节点指向较大键值的后面的节点

//i是叶节点分裂出来的新节点的最小键值对应的内层节点应该插入比他稍大一点的最小键值的位置

switch (i)

{

case 0: //第一种情况新节点在左父亲的第二个指针另外三个节点在右父亲上cur->ptr[1] = b;

b->parent = cur;

newnode->ptr[0] = node2;

newnode->ptr[1] = node3;

newnode->ptr[2] = node4;

node2->parent = newnode;

node3->parent = newnode;

node4->parent = newnode;

break;

case 1: //之后的情况依次将新节点b与右边节点交换

cur->ptr[1] = node2;

node2->parent = cur;

newnode->ptr[0] = b;

newnode->ptr[1] = node3;

newnode->ptr[2] = node4;

b->parent = newnode;

node3->parent = newnode;

node4->parent = newnode;

break;

case 2:

cur->ptr[1] = node2;

node2->parent = cur;

newnode->ptr[0] = node3;

newnode->ptr[1] = b;

newnode->ptr[2] = node4;

b->parent = newnode;

node3->parent = newnode;

node4->parent = newnode;

break;

case 3:

cur->ptr[1] = node2;

node2->parent = cur;

newnode->ptr[0] = node3;

newnode->ptr[1] = node4;

newnode->ptr[2] = b;

b->parent = newnode;

node3->parent = newnode;

node4->parent = newnode;

break;

default:

break;

}

newnode->key[0] = newnode->ptr[1]->key[0];

newnode->key[1] = newnode->ptr[2]->key[0];

//在根节点添加键值

//之后的代码与叶子的添加函数相同 value为右父亲的最小键值

Node * parent1 = cur->parent;

int value = newnode->ptr[0]->key[0];

if (parent1->num == 1) //父节点没满且只有一个值

{

parent1->num++;

if (parent1->key[0] < value) //新值在右边添加的情况直接在右边补上值和指针{

parent1->key[1] = value;

parent1->ptr[2] = newnode;

}

else//新的值在左边的话让原来的值右移一位

{

parent1->key[1] = parent1->key[0]; //右移一位

parent1->key[0] = value;

parent1->ptr[2] = parent1->ptr[1];

parent1->ptr[1] = newnode;

}

}

//父节点没满且有两个值

else if (parent1->num == 2)//情况同上

{

parent1->num++;

if (parent1->key[1] < value) //新值在右边添加的情况直接在右边补上值和指针

{

parent1->key[2] = value;

parent1->ptr[3] = newnode;

}

else if (parent1->key[0] < value) //在原来的两个值中插入

{

parent1->key[2] = parent1->key[1];

parent1->key[1] = value;

parent1->ptr[3] = parent1->ptr[2];

parent1->ptr[2] = newnode;

}

else

{

parent1->key[2] = parent1->key[1];

parent1->key[1] = parent1->key[0];

parent1->key[0] = value;

parent1->ptr[3] = parent1->ptr[2];

parent1->ptr[2] = parent1->ptr[1];

parent1->ptr[1] = newnode;

}

}

}

}

//******************************************************************************删除键值

void BTree::deleteKey(int id)

{

Result re = search(id);

if (!re.tag)

{