1640 lines
31 KiB
C++
1640 lines
31 KiB
C++
/*
|
||
* CBtree.h
|
||
*
|
||
* Created on: 2012-3-5
|
||
* Author: liyouhuan
|
||
*/
|
||
|
||
#ifndef CBTREEH_H_
|
||
#define CBTREEH_H_
|
||
|
||
|
||
#include<iostream>
|
||
#include<stdlib.h>
|
||
#include<stdio.h>
|
||
#include<string.h>
|
||
#include<time.h>
|
||
|
||
#include<unistd.h>
|
||
#include<sys/types.h>
|
||
#include<sys/stat.h>
|
||
|
||
#include<vector>
|
||
#include<queue>
|
||
#include<stack>
|
||
#include<set>
|
||
|
||
#define BLOCKSIZE (1 << 14)/* 16K */
|
||
#define ORDER_V 128 /* 为简单起见，把v固定为2，实际的B+树v值应该是可配的 */
|
||
#define MAXNUM_KEY (ORDER_V * 2) /* 内部结点中最多键个数，为2v ( 1~2v )*/
|
||
#define MAXNUM_POINTER (ORDER_V * 2 + 1) /* 内部结点中最多指向子树的指针个数，为2v ( 1~2v )*/
|
||
#define MAXNUM_DATA (ORDER_V * 2 + 1) /* 结点中用作定义，为2v ( 1~2v )*/
|
||
#define TERM_NUMBER 1
|
||
|
||
#define FLAG_LEFT 5
|
||
#define FLAG_RIGHT 6
|
||
#define FLAG_ZERO 7
|
||
#define FLAG_NO_ZERO 8
|
||
|
||
#define nFlush1 2500000
|
||
#define nFlush2 2000000
|
||
#define nFlush3 1500000
|
||
#define nFlush4 1000000
|
||
#define level1 6000000
|
||
#define level2 4000000
|
||
|
||
|
||
|
||
using namespace std;
|
||
|
||
enum NODE_TYPE
|
||
{
|
||
NODE_TYPE_INTERNAL = 2, // 内部结点
|
||
NODE_TYPE_LEAF = 3, // 叶子结点
|
||
};
|
||
enum eletype
|
||
{
|
||
B_CHARARRAY = 1,
|
||
B_INTEGER = 4,
|
||
};
|
||
extern eletype _eletype;
|
||
extern int _ii;
|
||
extern string filePath_o2sID;
|
||
extern string filePath_opID2sID;
|
||
extern string filePath_s2sID;
|
||
extern string filePath_sID2s;
|
||
extern int myStrcmp(char _str1[], int len1, char _str2[], int len2);
|
||
extern FILE * _log_btree;
|
||
|
||
class KeyType
|
||
{
|
||
public:
|
||
int _num_insert;
|
||
bool is_AtMem;
|
||
char* sKey;
|
||
int iKey;
|
||
int mLenKey; //关于是否读入\n的试验
|
||
KeyType()
|
||
{
|
||
KeyType_Initial();
|
||
}
|
||
KeyType(KeyType & a)
|
||
{
|
||
_num_insert = a._num_insert;
|
||
iKey = a.iKey;
|
||
mLenKey = a.mLenKey;
|
||
is_AtMem = a.is_AtMem;
|
||
this ->set_sKey(a.sKey, a.mLenKey);
|
||
}
|
||
void KeyType_Initial()
|
||
{
|
||
sKey = NULL;
|
||
iKey = -1;
|
||
mLenKey = -1;
|
||
is_AtMem = false;
|
||
_num_insert = -1;
|
||
}
|
||
~KeyType()
|
||
{
|
||
clear_skey();
|
||
}
|
||
void clear_skey()
|
||
{
|
||
if(sKey != NULL)
|
||
{
|
||
delete [] sKey;
|
||
sKey = NULL;
|
||
}
|
||
}
|
||
|
||
|
||
void set_sKey(const char * _str, int kLen)
|
||
{
|
||
if(_str == NULL)
|
||
{
|
||
sKey = NULL;
|
||
mLenKey = 0;
|
||
return;
|
||
}
|
||
if(sKey != NULL)
|
||
{
|
||
delete [] sKey;
|
||
sKey = NULL;
|
||
}
|
||
mLenKey = kLen;
|
||
sKey = new char[mLenKey + 1];
|
||
memcpy(sKey, _str, mLenKey);
|
||
sKey[mLenKey] = '\0';
|
||
}
|
||
void set_iKey(int _i)
|
||
{
|
||
mLenKey = 4;
|
||
iKey = _i;
|
||
}
|
||
|
||
void RandInputKey(int _i)
|
||
{
|
||
if(_eletype == B_CHARARRAY)
|
||
{
|
||
char _c_key[100] = "a";
|
||
int _input_key = rand() % 100000;
|
||
_input_key += _i * 3;
|
||
char _i_to_s[100] = "";
|
||
sprintf(_i_to_s, "%d", _input_key);
|
||
strcat(_c_key, _i_to_s);
|
||
mLenKey = (int)strlen(_c_key);
|
||
sKey = new char[mLenKey + 1];
|
||
strcpy(sKey, _c_key);
|
||
sKey[mLenKey] = '\0';
|
||
}
|
||
else
|
||
{
|
||
iKey = _i;
|
||
mLenKey = 4;
|
||
}
|
||
}
|
||
void HandInputKey()
|
||
{
|
||
if(_eletype == B_CHARARRAY)
|
||
{
|
||
cout << "input the key_string" << endl;
|
||
char _c_key[1000];
|
||
gets(_c_key);
|
||
gets(_c_key);
|
||
mLenKey = (int)strlen(_c_key);
|
||
sKey = new char[mLenKey + 1];
|
||
strcpy(sKey, _c_key);
|
||
sKey[mLenKey] = '\0';
|
||
}
|
||
else
|
||
{
|
||
cout << "input the key_integer" << endl;
|
||
int _input_key = 0;
|
||
scanf("%d", &_input_key);
|
||
iKey = _input_key;
|
||
mLenKey = 4;
|
||
}
|
||
}
|
||
|
||
void ReadKey(FILE * fp);
|
||
|
||
void WriteKey(FILE * fp);
|
||
/*
|
||
* 合适的功能函数
|
||
*/
|
||
int WriteSize()
|
||
{
|
||
int size_mLenKey = sizeof(mLenKey);
|
||
int size_Key = 4;
|
||
if(_eletype == B_CHARARRAY)
|
||
{
|
||
size_Key = (mLenKey + 1) * sizeof(char);
|
||
}
|
||
else
|
||
if(_eletype == B_INTEGER)
|
||
{
|
||
size_Key = sizeof(int);
|
||
}
|
||
else
|
||
{
|
||
printf("err in writesize of keytype\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
return size_mLenKey + size_Key;
|
||
}
|
||
|
||
void PrintKey()
|
||
{
|
||
if(_eletype == B_CHARARRAY)
|
||
{
|
||
printf("[%s,%d]", sKey, this ->mLenKey);
|
||
}
|
||
else
|
||
if(_eletype == B_INTEGER)
|
||
{
|
||
printf("%d", iKey);
|
||
}
|
||
else
|
||
{
|
||
printf("bug in pk\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
}
|
||
bool Gt(const KeyType & a)const
|
||
{
|
||
if(_eletype == B_CHARARRAY)
|
||
{
|
||
if(myStrcmp(sKey, mLenKey, a.sKey, a.mLenKey) > 0)
|
||
return true;
|
||
return false;
|
||
}
|
||
else
|
||
if(_eletype == B_INTEGER)
|
||
{
|
||
if(iKey > a.iKey)
|
||
return true;
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
printf("err in gt\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool Lt(const KeyType & a)const
|
||
{
|
||
if(_eletype == B_CHARARRAY)
|
||
{
|
||
if(myStrcmp(sKey, mLenKey, a.sKey, a.mLenKey) < 0)
|
||
return true;
|
||
return false;
|
||
}
|
||
else
|
||
if(_eletype == B_INTEGER)
|
||
{
|
||
if(iKey < a.iKey)
|
||
return true;
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
printf("err in gt\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool Eq(const KeyType & a)const
|
||
{
|
||
if(_eletype == B_CHARARRAY)
|
||
{
|
||
if(myStrcmp(sKey, mLenKey, a.sKey, a.mLenKey) == 0)
|
||
return true;
|
||
return false;
|
||
}
|
||
else
|
||
if(_eletype == B_INTEGER)
|
||
{
|
||
if(iKey == a.iKey)
|
||
return true;
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
printf("err in gt\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool operator >(const KeyType & a)const
|
||
{
|
||
return Gt(a);
|
||
}
|
||
|
||
bool operator >=(const KeyType & a)const
|
||
{
|
||
return Gt(a) || Eq(a);
|
||
}
|
||
|
||
bool operator <(const KeyType & a)const
|
||
{
|
||
return Lt(a);
|
||
}
|
||
|
||
bool operator <=(const KeyType & a)const
|
||
{
|
||
return Lt(a) || Eq(a);
|
||
}
|
||
|
||
bool operator ==(const KeyType & a)const
|
||
{
|
||
return Eq(a);
|
||
}
|
||
|
||
KeyType & operator = (const KeyType & a)
|
||
{
|
||
_num_insert = a._num_insert;
|
||
iKey = a.iKey;
|
||
mLenKey = a.mLenKey;
|
||
is_AtMem = a.is_AtMem;
|
||
this ->set_sKey(a.sKey, a.mLenKey);
|
||
return * this;
|
||
}
|
||
|
||
|
||
};
|
||
extern KeyType KeyNULL;
|
||
|
||
|
||
|
||
class mBlockLink
|
||
{
|
||
public:
|
||
long long int preBlockAddr;
|
||
long long int nextBlockAddr;
|
||
void mBlockLink_Initial()
|
||
{
|
||
preBlockAddr = -1;
|
||
nextBlockAddr = -1;
|
||
}
|
||
mBlockLink & operator=(mBlockLink & a)
|
||
{
|
||
preBlockAddr = a.preBlockAddr;
|
||
nextBlockAddr = a.nextBlockAddr;
|
||
return *this;
|
||
}
|
||
mBlockLink()
|
||
{
|
||
|
||
}
|
||
mBlockLink(mBlockLink & a)
|
||
{
|
||
preBlockAddr = a.preBlockAddr;
|
||
nextBlockAddr = a.nextBlockAddr;
|
||
}
|
||
};
|
||
|
||
|
||
class mValue
|
||
{
|
||
public:
|
||
char * Term[TERM_NUMBER];
|
||
int lenTerm[TERM_NUMBER];
|
||
~mValue()
|
||
{
|
||
for(int i = 0; i < TERM_NUMBER; i ++)
|
||
{
|
||
if(Term[i] != NULL)
|
||
{
|
||
delete [] Term[i];
|
||
Term[i] = NULL;
|
||
}
|
||
}
|
||
}
|
||
void mValue_Initial()
|
||
{
|
||
for(int i = 0; i < TERM_NUMBER; i ++)
|
||
{
|
||
if(Term[i] != NULL)
|
||
{
|
||
cout << "term mem lost" << endl;
|
||
system("pause");
|
||
system("pause"); exit(0);
|
||
}
|
||
Term[i] = NULL;
|
||
lenTerm[i] = 0;
|
||
}
|
||
}
|
||
|
||
void getValInteger(vector<int> & nodeSet)
|
||
{
|
||
{//for one order
|
||
/*
|
||
int _tag = 0;
|
||
int i_size = sizeof(int);
|
||
while(_tag + i_size <= lenTerm[0])
|
||
{
|
||
int _val = *( (int*)(Term[0]+_tag) );
|
||
nodeSet.push_back(_val);
|
||
_tag += 5;
|
||
}
|
||
*/
|
||
}
|
||
{//for the other order
|
||
int _tag = lenTerm[0];
|
||
int i_size = sizeof(int);
|
||
while(_tag - i_size >= 0)
|
||
{
|
||
int _val = *( (int*)(Term[0]+_tag - i_size) );
|
||
nodeSet.push_back(_val);
|
||
_tag -= 5;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
void iPrintval(int _i)
|
||
{
|
||
if(_i < 0 || _i > TERM_NUMBER - 1)
|
||
{
|
||
cout << "bug ipval" << endl;
|
||
system("pause"); exit(0);
|
||
}
|
||
if(Term[_i] == NULL)
|
||
{
|
||
cout << "bug ipvalt" << endl;
|
||
system("pause"); exit(0);
|
||
}
|
||
cout << Term[_i] << endl;
|
||
}
|
||
//think
|
||
mValue & operator=(const mValue & a)
|
||
{
|
||
for(int i = 0; i < TERM_NUMBER; i ++)
|
||
{
|
||
lenTerm[i] = a.lenTerm[i];
|
||
if(Term[i] != NULL)
|
||
{
|
||
delete [] Term[i];
|
||
Term[i] = NULL;
|
||
}
|
||
Term[i] = new char[lenTerm[i] + 1];
|
||
memcpy(Term[i], a.Term[i], lenTerm[i] + 1);
|
||
}
|
||
return *this;
|
||
}
|
||
mValue()
|
||
{
|
||
for(int i = 0; i < TERM_NUMBER; i ++)
|
||
{
|
||
Term[i] = NULL;
|
||
lenTerm[i] = 0;
|
||
}
|
||
}
|
||
// think
|
||
mValue(mValue & a)
|
||
{
|
||
for(int i = 0; i < TERM_NUMBER; i ++)
|
||
{
|
||
lenTerm[i] = a.lenTerm[i];
|
||
if(Term[i] != NULL)
|
||
{
|
||
delete [] Term[i];
|
||
Term[i] = NULL;
|
||
}
|
||
Term[i] = new char[lenTerm[i] + 1];
|
||
memcpy(Term[i], a.Term[i], lenTerm[i] + 1);
|
||
}
|
||
}
|
||
|
||
|
||
void set_iVal(int _i, const char * _str, int _str_len)
|
||
{
|
||
if(_i < 0 || _i > TERM_NUMBER - 1)
|
||
{
|
||
cout << "bug setival" << endl;
|
||
system("pause"); exit(0);
|
||
}
|
||
if(Term[_i] != NULL)
|
||
{
|
||
delete [] Term[_i];
|
||
Term[_i] = NULL;
|
||
}
|
||
|
||
Term[_i] = new char[_str_len + 1];
|
||
memcpy(Term[_i], _str, _str_len + 1);
|
||
lenTerm[_i] = _str_len;
|
||
|
||
Term[_i][ lenTerm[_i] ] = '\0';
|
||
|
||
}
|
||
|
||
bool delete_iVal(int _i, char * del_str, int & flag)
|
||
{
|
||
if(_i < 0 || _i > TERM_NUMBER - 1)
|
||
{
|
||
cout << "bug setival" << endl;
|
||
system("pause"); exit(0);
|
||
}
|
||
if(Term[_i] == NULL)
|
||
{
|
||
cout << "bug addival" << endl;
|
||
system("pause"); exit(0);
|
||
}
|
||
|
||
int _tag = 0;
|
||
int i_size = sizeof(int);
|
||
while(_tag + i_size <= lenTerm[0])
|
||
{
|
||
if(del_str[0] == Term[0][_tag] && del_str[1] == Term[0][_tag + 1] && del_str[2] == Term[0][_tag + 2]
|
||
&& del_str[3] == Term[0][_tag + 3])
|
||
break;
|
||
_tag += 5;
|
||
}
|
||
if(_tag + i_size > lenTerm[0])
|
||
{
|
||
flag = FLAG_NO_ZERO;
|
||
return false;
|
||
}
|
||
|
||
if(_tag + i_size == lenTerm[0])
|
||
{
|
||
Term[0][_tag] = '\0';
|
||
lenTerm[0] -= sizeof(int) + sizeof(char);
|
||
//只有一个元素时很特殊， 长度是减少4， 其余减少5
|
||
if(lenTerm[0] <= 0) flag = FLAG_ZERO;
|
||
else flag = FLAG_NO_ZERO;
|
||
return true;
|
||
}
|
||
|
||
|
||
for(int i = _tag; i + i_size < lenTerm[0]; i ++)
|
||
{
|
||
Term[0][i] = Term[0][i + i_size + 1];
|
||
}
|
||
lenTerm[0] -= sizeof(int) + sizeof(char);
|
||
flag = FLAG_NO_ZERO;
|
||
return true;
|
||
}
|
||
|
||
void add_iVal(int _i, const char *add_str)
|
||
{
|
||
if(_i < 0 || _i > TERM_NUMBER - 1)
|
||
{
|
||
cout << "bug setival" << endl;
|
||
system("pause"); exit(0);
|
||
}
|
||
if(Term[_i] == NULL)
|
||
{
|
||
cout << "bug addival" << endl;
|
||
system("pause"); exit(0);
|
||
}
|
||
char * _tmp_term_i = NULL;
|
||
|
||
|
||
int _tag = 0;
|
||
int i_size = sizeof(int);
|
||
while(_tag + i_size <= lenTerm[0])
|
||
{
|
||
if(add_str[0] == Term[0][_tag] && add_str[1] == Term[0][_tag + 1] && add_str[2] == Term[0][_tag + 2]
|
||
&& add_str[3] == Term[0][_tag + 3])
|
||
return;
|
||
_tag += 5;
|
||
}
|
||
|
||
int newLen = sizeof(int) + sizeof(char) + lenTerm[_i];
|
||
|
||
_tmp_term_i = new char[ newLen + 1];
|
||
|
||
memcpy(_tmp_term_i, add_str, 4 + 1);
|
||
_tmp_term_i[4] = ' ';
|
||
memcpy(_tmp_term_i + 5, Term[_i], lenTerm[_i] + 1);
|
||
lenTerm[0] = newLen;
|
||
_tmp_term_i[ lenTerm[_i] ] = '\0';
|
||
|
||
if(Term[_i] != NULL)
|
||
{
|
||
delete [] Term[_i];
|
||
Term[_i] = NULL;
|
||
}
|
||
else
|
||
{
|
||
cout << "bug term" << endl;
|
||
system("pause");
|
||
exit(0);
|
||
}
|
||
Term[_i] = _tmp_term_i;
|
||
}
|
||
void InputVal()
|
||
{
|
||
char _input_str[1000] = "helloworld";
|
||
for(int i = 0; i < TERM_NUMBER; i ++)
|
||
{
|
||
lenTerm[i] = (int)strlen(_input_str);
|
||
Term[i] = new char[lenTerm[i] + 1];
|
||
strcpy(Term[i], _input_str);
|
||
Term[i][ lenTerm[i] ] = '\0';
|
||
}
|
||
}
|
||
|
||
void FputVal(FILE * fp)
|
||
{
|
||
|
||
}
|
||
void ReadVal(FILE * fp);
|
||
void WriteVal(FILE * fp);
|
||
int WriteSize()
|
||
{
|
||
int _sum_size = 0;
|
||
for(int i = 0; i < TERM_NUMBER; i ++)
|
||
{
|
||
_sum_size += lenTerm[i] + 1;
|
||
}
|
||
_sum_size += TERM_NUMBER * (sizeof(int));
|
||
return _sum_size;
|
||
}
|
||
void PrintVal()
|
||
{
|
||
for(int i = 0; i < TERM_NUMBER; i ++)
|
||
{
|
||
if(Term[i] != NULL)
|
||
printf("%s == ", Term[i]);
|
||
cout << "len = " << lenTerm[i] << endl;
|
||
}
|
||
}
|
||
};
|
||
|
||
class mQueue
|
||
{
|
||
public:
|
||
// static const int qLenth = 5243005; /* 5*1024*1024 */
|
||
static const int qLenth = 20971520; /* 20*1024*1024 */
|
||
int qUsed;
|
||
bool qAvailable[mQueue::qLenth];
|
||
|
||
public:
|
||
mQueue()
|
||
{
|
||
Initial();
|
||
}
|
||
|
||
void Initial()
|
||
{
|
||
qAvailable[0] = false;
|
||
qUsed = 1;
|
||
for(int i = 1; i < mQueue::qLenth; i ++)
|
||
{
|
||
qAvailable[i] = true;
|
||
}
|
||
}
|
||
|
||
void Push(long long int _iq)
|
||
{
|
||
if(_iq % BLOCKSIZE != 0)
|
||
{
|
||
printf("bug in _iq\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
_iq /= BLOCKSIZE;
|
||
if(qAvailable[_iq] || _iq >= mQueue::qLenth)// for check
|
||
{
|
||
printf("err in queue_insert: qLenth = %d\n", mQueue::qLenth);
|
||
_iq %= mQueue::qLenth;
|
||
}
|
||
// cout << "block back: " << (_iq * BLOCKSIZE) << endl;
|
||
qAvailable[_iq] = true;
|
||
qUsed --;
|
||
}
|
||
|
||
void MulPush(long long int _iq[], int _qlen)
|
||
{
|
||
for(int i = 0; i < _qlen; i ++)
|
||
{
|
||
Push(_iq[i]);
|
||
}
|
||
}
|
||
|
||
void MulPush(const vector<long long int>& _back_vec){
|
||
vector<long long int>::const_iterator citr;
|
||
for(citr = _back_vec.begin(); citr != _back_vec.end(); citr++){
|
||
this ->Push(*citr);
|
||
}
|
||
}
|
||
|
||
long long int Pop()
|
||
{
|
||
for(int i = 0; i < mQueue::qLenth; i ++)
|
||
{
|
||
if(qAvailable[i])
|
||
{
|
||
long long int lli_tmp = i;
|
||
lli_tmp = lli_tmp * BLOCKSIZE;
|
||
// cout << "block out: " << (lli_tmp) << endl;
|
||
qAvailable[i] = false;
|
||
qUsed ++;
|
||
return lli_tmp;
|
||
}
|
||
}
|
||
printf("err in queue_pop\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
|
||
void ReadQueue(char * _queuefile)
|
||
{
|
||
FILE * fp;
|
||
if((fp = fopen(_queuefile, "rb+")) == NULL)
|
||
{
|
||
printf("err in open r_queuefile\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
else
|
||
{
|
||
fread(&qUsed, sizeof(int), 1, fp);
|
||
fread(qAvailable, sizeof(bool), mQueue::qLenth, fp);
|
||
// printf("qLenth = %d\n", qLenth);
|
||
}
|
||
fclose(fp);
|
||
}
|
||
|
||
void WriteQueue(char * _queuefile)
|
||
{
|
||
FILE * fp;
|
||
if((fp = fopen(_queuefile, "wb+")) == NULL)
|
||
{
|
||
printf("err in open w_queuefile\n");
|
||
system("pause"); exit(0);
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
fwrite(&qUsed, sizeof(int), 1, fp);
|
||
fwrite(qAvailable, sizeof(bool), mQueue::qLenth, fp);
|
||
}
|
||
fclose(fp);
|
||
}
|
||
|
||
int BlockUsed()
|
||
{
|
||
return qUsed;
|
||
}
|
||
|
||
};
|
||
|
||
class mLeafNode;
|
||
class mItnlNode;
|
||
class BPlusTree;
|
||
|
||
class mNode
|
||
{
|
||
public:
|
||
|
||
void mNode_Initial()
|
||
{
|
||
Modify = true; Count = 0;
|
||
AddrFB = -1; mFather = NULL;
|
||
}
|
||
virtual ~mNode() { }
|
||
|
||
void setModify() { Modify = true; }
|
||
bool getModify() { return Modify; }
|
||
void unModify() { Modify = false; }
|
||
int getCount() { return Count; }
|
||
void setCount(int _count) { Count = _count; }
|
||
void IncCount() { Count ++; }
|
||
void DecCount() { Count --; }
|
||
long long int getAddrFB() { return AddrFB; }
|
||
void setAddrFB(long long int _addrfb){AddrFB = _addrfb; }
|
||
NODE_TYPE getType() { return Type; }
|
||
void setType(NODE_TYPE _type) { Type = _type; }
|
||
mNode * getFather() { return mFather; }
|
||
void setFather(mNode * _mpather) {mFather = _mpather;}
|
||
virtual mNode * getPointer(int _i) { return NULL; }
|
||
virtual void setPointer(int _i, mNode * _mnode) { }
|
||
virtual bool isInMemory(int _i) { return false; }
|
||
virtual void setMemory(int _i) { }
|
||
virtual int iInsert(KeyType & _keytype) {return 0; }
|
||
virtual KeyType & getKey(int _i) { return KeyNULL; }
|
||
virtual void setKey(int _i, KeyType &_keytype){ }
|
||
virtual void printNode() { return; }
|
||
|
||
mNode * getBrother(int & flag)
|
||
{
|
||
mNode * _pFather = this ->getFather();
|
||
if(_pFather == NULL) return NULL;
|
||
|
||
mNode * _pBrother = NULL;
|
||
for(int i = 1; i <= _pFather ->getCount(); i ++)
|
||
{
|
||
//ָ<><D6B8>ƥ<EFBFBD><C6A5>
|
||
if(_pFather ->getPointer(i) == this)
|
||
{
|
||
if(i == (_pFather ->getCount()) + 1)
|
||
{
|
||
flag = FLAG_LEFT;
|
||
_pBrother = _pFather ->getPointer(i - 1);
|
||
}
|
||
else
|
||
{
|
||
flag = FLAG_RIGHT;
|
||
_pBrother = _pFather ->getPointer(i + 1);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
if(_pBrother == NULL)
|
||
{
|
||
cout << "bug run here" << endl;
|
||
}
|
||
return _pBrother;
|
||
}
|
||
|
||
mItnlNode * ifordebug;
|
||
mLeafNode * lfordebug;
|
||
|
||
private:
|
||
int Count;
|
||
long long int AddrFB;
|
||
bool Modify;
|
||
NODE_TYPE Type;
|
||
mNode * mFather;
|
||
};
|
||
|
||
|
||
class mitnldata
|
||
{
|
||
public:
|
||
|
||
KeyType mKey;
|
||
mNode * mPointer;
|
||
long long int mAddr_sonFB;
|
||
|
||
void mitnldata_Initial()
|
||
{
|
||
mKey.KeyType_Initial();
|
||
mPointer = NULL;
|
||
mAddr_sonFB = -1;
|
||
}
|
||
|
||
mitnldata & operator=(mitnldata & a)
|
||
{
|
||
mKey = a.mKey;
|
||
mPointer = a.mPointer;
|
||
mAddr_sonFB = a.mAddr_sonFB;
|
||
return *this;
|
||
}
|
||
void cleardata()
|
||
{
|
||
mKey.clear_skey();
|
||
}
|
||
~mitnldata()
|
||
{
|
||
}
|
||
|
||
mitnldata() {}
|
||
mitnldata(mitnldata & a)
|
||
{
|
||
mKey = a.mKey;
|
||
mPointer = a.mPointer;
|
||
mAddr_sonFB = a.mAddr_sonFB;
|
||
}
|
||
|
||
bool operator >(const mitnldata & a) { return mKey > a.mKey; }
|
||
bool operator <(const mitnldata & a) { return mKey < a.mKey; }
|
||
|
||
void Hand_inputkey() { mKey.HandInputKey(); }
|
||
void Rand_inputkey(int _i) { mKey.RandInputKey(_i); }
|
||
|
||
void Read_mitnldata(FILE * fp);
|
||
bool Write_mitnldata( FILE * fp, int & _size_left );
|
||
};
|
||
|
||
class mItnlNode : public mNode
|
||
{
|
||
public:
|
||
|
||
mitnldata ItnlData[MAXNUM_DATA];
|
||
mItnlNode()
|
||
{
|
||
mNode_Initial();
|
||
ifordebug = this;
|
||
lfordebug = NULL;
|
||
setType(NODE_TYPE_INTERNAL);
|
||
for(int i = 0; i <= MAXNUM_KEY; i ++)
|
||
{
|
||
ItnlData[i].mitnldata_Initial();
|
||
}
|
||
}
|
||
~mItnlNode()
|
||
{
|
||
}
|
||
|
||
KeyType & getKey(int _i)
|
||
{
|
||
if(_i > 0 && _i <= getCount())
|
||
{
|
||
return ItnlData[_i].mKey;
|
||
}
|
||
else
|
||
{
|
||
printf("err in getkey\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
return KeyNULL;
|
||
}
|
||
void setKey(int _i, const KeyType &_keytype)
|
||
{
|
||
if(_i > 0 && _i <= MAXNUM_KEY )
|
||
{
|
||
ItnlData[_i].mKey = _keytype;
|
||
}
|
||
else
|
||
{
|
||
printf("err in setkey\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
return;
|
||
}
|
||
|
||
mitnldata & getElement(int _i)
|
||
{
|
||
if(_i > 0 && _i <= getCount())
|
||
{
|
||
return ItnlData[_i];
|
||
}
|
||
else
|
||
{
|
||
printf("err in getele\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
return ItnlData[0];
|
||
}
|
||
|
||
void setElement(int _i, mitnldata & _itnldata)
|
||
{
|
||
if(_i > 0 && _i <= MAXNUM_KEY)
|
||
{
|
||
ItnlData[_i] = _itnldata;
|
||
}
|
||
else
|
||
{
|
||
printf("err in setele\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
}
|
||
|
||
mNode * getPointer(int _i)
|
||
{
|
||
if(_i > 0 && _i <= getCount())
|
||
{
|
||
return ItnlData[_i].mPointer;
|
||
}
|
||
else
|
||
{
|
||
printf("err in getpointer\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
void setPointer(int _i, mNode * _mpointer)
|
||
{
|
||
if(_i > 0 && _i <= MAXNUM_POINTER)
|
||
{
|
||
ItnlData[_i].mPointer = _mpointer;
|
||
// setFather !!!!!
|
||
_mpointer ->setFather(this);
|
||
}
|
||
else
|
||
{
|
||
printf("err in setpointer\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
}
|
||
|
||
//此函数需仔细考虑~~！！
|
||
int iExist(const KeyType &_keytype)
|
||
{
|
||
int _ibegin = 1, _iend = getCount();
|
||
int _imiddle;
|
||
while(_ibegin < _iend)
|
||
{
|
||
_imiddle = (_ibegin + _iend) / 2;
|
||
if(ItnlData[_ibegin].mKey == _keytype)
|
||
{
|
||
return _ibegin;
|
||
}
|
||
if(ItnlData[_iend].mKey == _keytype)
|
||
{
|
||
return _iend;
|
||
}
|
||
|
||
if(_ibegin == _iend - 1) return -1;
|
||
// 后加可能有风险
|
||
|
||
if(ItnlData[_imiddle].mKey > _keytype)
|
||
{
|
||
_iend = _imiddle;
|
||
}
|
||
else
|
||
{
|
||
_ibegin = _imiddle;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
int iInsert(const KeyType & _keytype)
|
||
{
|
||
int _ibegin = 1, _iend = getCount();
|
||
int _imiddle;
|
||
while(_ibegin < _iend)
|
||
{
|
||
_imiddle = (_ibegin + _iend) / 2;
|
||
if(ItnlData[_iend].mKey < _keytype)
|
||
{
|
||
return _iend + 1;
|
||
}
|
||
if(ItnlData[_ibegin].mKey < _keytype && ItnlData[_ibegin + 1].mKey > _keytype)
|
||
{
|
||
return _ibegin + 1;
|
||
}
|
||
if(ItnlData[_imiddle].mKey > _keytype)
|
||
{
|
||
_iend = _imiddle;
|
||
}
|
||
else
|
||
{
|
||
_ibegin = _imiddle;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
int iNextFloor(const KeyType & _keytype)
|
||
{
|
||
int _ibegin, _iend, _imiddle;
|
||
_ibegin = 1;
|
||
_iend = getCount();
|
||
|
||
if(ItnlData[_ibegin].mKey > _keytype)
|
||
{
|
||
// printf("less than _ibegin\n");
|
||
return -1;
|
||
}
|
||
|
||
while(_ibegin < _iend)
|
||
{
|
||
_imiddle = (_ibegin + _iend) / 2;
|
||
if(ItnlData[_iend].mKey <= _keytype)
|
||
{
|
||
return _iend;
|
||
}
|
||
if(ItnlData[_ibegin].mKey <= _keytype && ItnlData[_ibegin + 1].mKey > _keytype)
|
||
{
|
||
return _ibegin;
|
||
}
|
||
if(ItnlData[_imiddle].mKey > _keytype)
|
||
{
|
||
_iend = _imiddle;
|
||
}
|
||
else
|
||
{
|
||
_ibegin = _imiddle;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
bool isInMemory(int _i)
|
||
{
|
||
if(_i > 0 && _i <= getCount())
|
||
{
|
||
if(ItnlData[_i].mKey.is_AtMem)
|
||
return true;
|
||
else
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
printf("err in isinmemeory\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
}
|
||
void setMemory(int _i)
|
||
{
|
||
if(_i > 0 && _i <= getCount())
|
||
{
|
||
ItnlData[_i].mKey.is_AtMem = true;
|
||
}
|
||
else
|
||
{
|
||
printf("err in setmemeory\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
}
|
||
|
||
long long int getSonAddr(int _i)
|
||
{
|
||
if(_i > 0 && _i <= getCount())
|
||
{
|
||
return ItnlData[_i].mAddr_sonFB;
|
||
}
|
||
else
|
||
{
|
||
printf("err in getsonaddr\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
}
|
||
void setSonAddr(int _i, long long int _addr_son)
|
||
{
|
||
if(_i > 0 && _i <= MAXNUM_KEY)
|
||
{
|
||
ItnlData[_i].mAddr_sonFB = _addr_son;
|
||
}
|
||
else
|
||
{
|
||
printf("err in getsonaddr\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
}
|
||
|
||
void printNode()
|
||
{
|
||
printf(" == ");
|
||
for(int i = 1; i <= getCount(); i ++)
|
||
{
|
||
ItnlData[i].mKey.PrintKey();
|
||
printf(" ");
|
||
}
|
||
printf(" == ");
|
||
}
|
||
|
||
// 插入键
|
||
// 最左端递归向上
|
||
bool Insert(mNode* _pmnode);
|
||
// 删除键
|
||
int Delete(const KeyType & _keytype);
|
||
// 分裂结点
|
||
KeyType & Split(mItnlNode* _mitnlnode);
|
||
// 结合结点
|
||
bool Combine(mItnlNode * _pmnode);
|
||
// 从另一结点移一个元素到本结点
|
||
bool MoveOneElement(mNode * _pmnode);
|
||
|
||
};
|
||
|
||
|
||
class mleafdata
|
||
{
|
||
public:
|
||
KeyType mData;
|
||
mValue * pVal;
|
||
void mleafdata_Initial()
|
||
{
|
||
if(mData.sKey != NULL || pVal != NULL)
|
||
{
|
||
cout << "mem lost" << endl;
|
||
system("pause");
|
||
system("pause"); exit(0);
|
||
}
|
||
mData.KeyType_Initial();
|
||
pVal = NULL;
|
||
}
|
||
|
||
|
||
~mleafdata()
|
||
{
|
||
cleardata();
|
||
}
|
||
mleafdata()
|
||
{
|
||
mData.KeyType_Initial();
|
||
pVal = NULL;
|
||
}
|
||
|
||
void cleardata()
|
||
{
|
||
if(pVal != NULL)
|
||
{
|
||
delete pVal;
|
||
pVal = NULL;
|
||
}
|
||
mData.clear_skey();
|
||
}
|
||
|
||
void assign_val_ptr(mleafdata & a)
|
||
{
|
||
this->pVal = a.pVal;
|
||
}
|
||
|
||
// think
|
||
mleafdata & operator = (const mleafdata & a)
|
||
{
|
||
mData = a.mData;
|
||
if(pVal != NULL)
|
||
{
|
||
delete pVal;
|
||
pVal = NULL;
|
||
}
|
||
pVal = new mValue;
|
||
pVal ->mValue_Initial();
|
||
*pVal = *(a.pVal);
|
||
return * this;
|
||
}
|
||
|
||
void SubIDPrint()
|
||
{
|
||
mData.PrintKey();
|
||
cout << " k 2 v " << endl;
|
||
vector<int> nSet;
|
||
pVal ->getValInteger(nSet);
|
||
for(unsigned int i = 0; i < nSet.size(); i ++)
|
||
{
|
||
cout << nSet[i] << " ";
|
||
if(i % 50 == 0) cout << endl;
|
||
}
|
||
}
|
||
void PrintLeafdata()
|
||
{
|
||
mData.PrintKey();
|
||
cout << " k2v ";
|
||
pVal ->PrintVal();
|
||
}
|
||
void fPrintLeafdata(FILE *fp)
|
||
{
|
||
char * skey = mData.sKey;
|
||
char * sterm = pVal ->Term[0];
|
||
fprintf(fp, "%s\n\n\n", skey);
|
||
fprintf(fp, "%s\n\n\n", sterm);
|
||
return;
|
||
}
|
||
|
||
void iPrintdata(int _i)
|
||
{
|
||
pVal ->iPrintval(_i);
|
||
}
|
||
|
||
void getdataInteger(vector<int> & nodeSet)
|
||
{
|
||
if(pVal == NULL)
|
||
{
|
||
cout << "bug pval" << endl;
|
||
system("pause"); exit(0);
|
||
}
|
||
pVal ->getValInteger(nodeSet);
|
||
}
|
||
|
||
void fputLeafdata(FILE * fp)
|
||
{
|
||
char _str[5][100];
|
||
char _latter[500];
|
||
int _ikey = 0;
|
||
if(pVal != NULL)
|
||
{
|
||
delete pVal;
|
||
pVal = NULL;
|
||
}
|
||
pVal = new mValue;
|
||
pVal ->mValue_Initial();
|
||
if(_eletype == B_CHARARRAY)
|
||
{
|
||
fprintf(fp, "%s %s %s %s %s ", _str[0], _str[1], _str[2], _str[3], _str[4]);
|
||
fgets(_latter, 500, fp);
|
||
mData.set_sKey(_str[0], (int)strlen(_str[0]));
|
||
for(int i = 0; i <= 3; i ++) pVal ->set_iVal(i, _str[i + 1], (int)strlen(_str[i + 1]));
|
||
pVal ->set_iVal(4, _latter, (int)strlen(_latter));
|
||
}
|
||
else
|
||
if(_eletype == B_INTEGER)
|
||
{
|
||
fprintf(fp, "%d %s %s %s %s ", _ikey, _str[1], _str[2], _str[3], _str[4]);
|
||
fgets(_latter, 500, fp);
|
||
mData.set_iKey(_ikey);
|
||
for(int i = 0; i <= 3; i ++) pVal ->set_iVal(i, _str[i + 1], (int)strlen(_str[i + 1]));
|
||
pVal ->set_iVal(4, _latter, (int)strlen(_latter));
|
||
}
|
||
else
|
||
{
|
||
cout << "bug fput" << endl;
|
||
system("pause"); exit(0);
|
||
}
|
||
}
|
||
|
||
void set_iKey_sValue(int _ikey, char _sval[])
|
||
{
|
||
mData.set_iKey(_ikey);
|
||
}
|
||
|
||
void set_sKey_sValue(const char _skey[], int _klen, const char _sval[], int val_len)
|
||
{
|
||
if(pVal != NULL)
|
||
{
|
||
delete pVal;
|
||
pVal = NULL;
|
||
}
|
||
pVal = new mValue;
|
||
pVal ->mValue_Initial();;
|
||
mData.set_sKey(_skey, _klen);
|
||
pVal ->set_iVal(0, _sval, val_len);
|
||
}
|
||
|
||
|
||
bool deletePartVal(char PartVal[], int & flag)
|
||
{
|
||
if(pVal == NULL)
|
||
{
|
||
cout << "null error" << endl;
|
||
system("pause");
|
||
exit(0);
|
||
}
|
||
return pVal ->delete_iVal(0, PartVal, flag);
|
||
}
|
||
|
||
void inputLeafdata()
|
||
{
|
||
if(pVal == NULL)
|
||
{
|
||
pVal = new mValue;
|
||
}
|
||
pVal ->InputVal();
|
||
}
|
||
|
||
// think
|
||
mleafdata(mleafdata & a)
|
||
{
|
||
mData = a.mData;
|
||
pVal = new mValue;
|
||
pVal ->mValue_Initial();
|
||
*pVal = *(a.pVal);
|
||
}
|
||
|
||
bool operator > (const mleafdata & a)
|
||
{
|
||
return mData > a.mData;
|
||
}
|
||
bool operator < (const mleafdata & a)
|
||
{
|
||
return mData < a.mData;
|
||
}
|
||
|
||
void Hand_inputkey() { mData.HandInputKey(); }
|
||
void Rand_inputkey(int i) { mData.RandInputKey(i); }
|
||
|
||
bool Read_mleafdata(FILE * fp);
|
||
bool Write_mleafdata(FILE * fp, int & _size_left, int & _key_size, int & _val_size);
|
||
};
|
||
|
||
class mLeafNode : public mNode
|
||
{
|
||
public:
|
||
mLeafNode* preNode;
|
||
mLeafNode* nextNode;
|
||
mBlockLink leafLink;
|
||
mleafdata LeafData[MAXNUM_DATA];
|
||
|
||
mLeafNode()
|
||
{
|
||
mNode_Initial();
|
||
lfordebug = this;
|
||
ifordebug = NULL;
|
||
preNode = NULL;
|
||
nextNode = NULL;
|
||
leafLink.mBlockLink_Initial();
|
||
setType(NODE_TYPE_LEAF);
|
||
for(int i = 0; i <= MAXNUM_KEY; i ++)
|
||
{
|
||
LeafData[i].mleafdata_Initial();
|
||
}
|
||
}
|
||
~mLeafNode()
|
||
{
|
||
}
|
||
//
|
||
// ~mLeafNode()
|
||
// {
|
||
// cout << "call leaf" << this ->getCount() << endl;
|
||
// for(int i = 1; i <= this ->getCount(); i ++)
|
||
// {
|
||
// LeafData[i].cleardata();
|
||
// }
|
||
// cout << "here1328" << endl;
|
||
// }
|
||
|
||
KeyType & getKey(int _i)
|
||
{
|
||
if(_i > 0 && _i <= getCount())
|
||
{
|
||
return LeafData[_i].mData;
|
||
}
|
||
else
|
||
{
|
||
printf("err in leaf getkey\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
return KeyNULL;
|
||
}
|
||
|
||
void setKey(int _i, KeyType & _keytype)
|
||
{
|
||
if(_i > 0 && _i <= MAXNUM_KEY)
|
||
{
|
||
LeafData[_i].mData = _keytype;
|
||
}
|
||
else
|
||
{
|
||
printf("err in leaf setkey\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
}
|
||
|
||
mleafdata & getElement(int _i)
|
||
{
|
||
if(_i > 0 && _i <= getCount())
|
||
{
|
||
return LeafData[_i];
|
||
}
|
||
else
|
||
{
|
||
printf("err in getele\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
}
|
||
|
||
void setElement(int _i, const mleafdata & _leafdata)
|
||
{
|
||
if(_i > 0 && _i <= MAXNUM_KEY)
|
||
{
|
||
LeafData[_i] = _leafdata;
|
||
}
|
||
else
|
||
{
|
||
printf("err in setele\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
}
|
||
|
||
// 此两个函数对叶节点无意义
|
||
mNode * getPointer(int _i)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
void setPointer(int _i, mNode * _pmnode)
|
||
{
|
||
return;
|
||
}
|
||
|
||
int iExist(const KeyType & _keytype)
|
||
{
|
||
int _ibegin = 1, _iend = getCount();
|
||
int _imiddle;
|
||
if(_iend <= 0){
|
||
// cout << "not found for the bug of getCount : " << _iend << endl;
|
||
return -1;
|
||
}
|
||
if(LeafData[1].mData == _keytype)
|
||
return 1;
|
||
while(_ibegin < _iend)
|
||
{
|
||
_imiddle = (_ibegin + _iend) / 2;
|
||
if(LeafData[_ibegin].mData == _keytype)
|
||
{
|
||
return _ibegin;
|
||
}
|
||
if(LeafData[_iend].mData == _keytype)
|
||
{
|
||
return _iend;
|
||
}
|
||
if(_ibegin + 1 == _iend){
|
||
return -1;
|
||
}
|
||
if(LeafData[_imiddle].mData > _keytype)
|
||
{
|
||
_iend = _imiddle;
|
||
}
|
||
else
|
||
{
|
||
_ibegin = _imiddle;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
// 考虑cout = 0的情况
|
||
int iInsert(const KeyType & _keytype)
|
||
{
|
||
int _ibegin = 1, _iend = getCount();
|
||
int _imiddle;
|
||
if(_iend <= 0 || LeafData[_ibegin].mData > _keytype)
|
||
{
|
||
// cout << "iInsert ret 1!!" << endl;
|
||
return 1;
|
||
}
|
||
// count = 0 && count = 1
|
||
if(LeafData[_iend].mData < _keytype)
|
||
{
|
||
return _iend + 1;
|
||
}
|
||
while(_ibegin < _iend)
|
||
{
|
||
_imiddle = (_ibegin + _iend) / 2;
|
||
if(LeafData[_ibegin].mData < _keytype && LeafData[_ibegin + 1].mData > _keytype)
|
||
{
|
||
return _ibegin + 1;
|
||
}
|
||
if(LeafData[_imiddle].mData > _keytype)
|
||
{
|
||
_iend = _imiddle;
|
||
}
|
||
else
|
||
{
|
||
_ibegin = _imiddle;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
bool isInMemory(int _i)
|
||
{
|
||
if(_i > 0 && _i <= getCount())
|
||
{
|
||
if(LeafData[_i].mData.is_AtMem)
|
||
return true;
|
||
else
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
printf("err in setmemeory\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
}
|
||
void setMemory(int _i)
|
||
{
|
||
if(_i > 0 && _i <= getCount())
|
||
{
|
||
LeafData[_i].mData.is_AtMem = true;
|
||
}
|
||
else
|
||
{
|
||
printf("err in setmemeory\n");
|
||
system("pause"); exit(0);
|
||
}
|
||
}
|
||
|
||
void printNode()
|
||
{
|
||
printf(" == ");
|
||
for(int i = 1; i <= getCount(); i ++)
|
||
{
|
||
LeafData[i].mData.PrintKey();
|
||
printf(" ");
|
||
}
|
||
printf(" == ");
|
||
}
|
||
|
||
|
||
|
||
// 插入数据
|
||
// 最左端递归向上
|
||
bool Insert(const mleafdata & _leafdata);
|
||
// 删除数据
|
||
int Delete(KeyType & _keytype);
|
||
//重载delete partval
|
||
int Delete(KeyType & _keytype, char partval[], int & pvFlag);
|
||
// 分裂结点
|
||
KeyType & Split(mLeafNode* _mpnode);
|
||
// 结合结点
|
||
bool Combine(mLeafNode* _mpnode);
|
||
// 重复插入
|
||
bool dupInsert(const mleafdata & _leafdata, int _index_insert);
|
||
};
|
||
|
||
extern mNode* ReadNode(FILE * fp, long long int _addr);
|
||
extern void WriteNode(mNode * pNode, FILE * fp, mQueue & _mqueue);
|
||
extern void DelDisk(FILE * fp, long long int _addr, mQueue & _mqueue);
|
||
extern void FP_Initial(FILE * & _fp);
|
||
extern bool DATAINPUT(FILE * ifp, char _row_str[], char _str[][600] );
|
||
extern void BuildTree();
|
||
extern bool Delete_KeyVal(char keyStr[], int keyLen, BPlusTree * _ptree);
|
||
extern bool Delete_Key_PartVal(char keyStr[], int keyLen, char partVal[], BPlusTree * _ptree);
|
||
extern bool Delete_sID2sub(int _sID, BPlusTree * _p_sID2sub);
|
||
extern bool Delete_s2sID(char _sub_str[], BPlusTree * _p_s2sID);
|
||
extern bool Delete_obj2sID(char _obj_str[], int _del_sID, BPlusTree * _p_obj2sID);
|
||
extern bool Delete_objpID2sID(char _obj_str[], int _pID, int _del_sID, BPlusTree * _p_objpID2sID);
|
||
|
||
|
||
/* B+树数据结构 */
|
||
class BPlusTree
|
||
{
|
||
public:
|
||
|
||
// 以下两个变量用于实现双向链表
|
||
mLeafNode* pmLeafHead; // 头结点
|
||
mLeafNode* pmLeafTail; // 尾结点
|
||
mNode * mRoot; // 根结点
|
||
mQueue mblockQueue;
|
||
FILE * mfp;
|
||
char mTreeName[1024];
|
||
int mDepth; // 树的深度
|
||
int insert_count;
|
||
|
||
void Initial();
|
||
BPlusTree(const char * const_tree_name, const char * _build_or_open);
|
||
~BPlusTree();
|
||
string getTreeFileName();
|
||
void log(const char* _log)const;
|
||
void forcheck();
|
||
|
||
// 获取和设置根结点
|
||
mNode * getRoot() { return mRoot; }
|
||
|
||
void setRoot(mNode * root) { mRoot = root; }
|
||
void Flush();
|
||
// 为插入而查找叶子结点
|
||
mLeafNode * SearchLeafNode(const KeyType & data)const;
|
||
//插入键到中间结点
|
||
bool InsertItnlNode(mItnlNode * pNode, mNode * pSon);
|
||
// 在中间结点中删除键
|
||
bool DeleteItnlNode(mItnlNode * pNode, KeyType & key);
|
||
// 查找指定的数据
|
||
bool Search(KeyType & data, mleafdata & _ret);
|
||
// 插入指定的数据
|
||
bool Insert(const mleafdata & _mleafdata);
|
||
// 删除指定的数据
|
||
bool Delete(KeyType & data);
|
||
// 重载删除函数
|
||
bool Delete(KeyType & data, char PartVal[]);
|
||
// 清除树
|
||
void ClearTree();
|
||
// 打印树
|
||
void PrintTree();
|
||
//读出根节点
|
||
void ReadRoot();
|
||
//保存树结构
|
||
void StoreTree();
|
||
|
||
};
|
||
#endif /* CBTREE_H_ */
|
||
|