二叉查找树

template<typename Key, typename Value>
class BSTree
{
public:
typedef struct _TagNode
{
Key _Key;
Value _Value;
struct _TagNode* _pLeft,* _pRight;    //子树
size_t _n;                //以该节点为根的子树节点总数(包含自己)
_TagNode(const Key& keyData, const Value& valueData, size_t nNumber)
: _Key(keyData), _Value(valueData), _n(nNumber), _pLeft(nullptr), _pRight(nullptr)
{

}
_TagNode()
: _Key(Key()), _Value(Value()), _n(0), _pLeft(nullptr), _pRight(nullptr)
{

}
}Node;

public:
BSTree() : _pRoot(nullptr)
{

}

~BSTree()
{
if(_pRoot)
Destory(_pRoot);    //销毁树
}

//获取根节点
const Node* getRoot()
{
return _pRoot;
}

//获取一个节点
Node* get(const Key& key)
{
return get(_pRoot, key);
}

//添加一个新的节点
void put(const Key& key, const Value& value)
{
put(&_pRoot, key, value);
}

//树的最小值节点
Node* min()
{
if (_pRoot == nullptr)
return nullptr;
return min(_pRoot);
}

//树的最大值节点
Node* max()
{
if (_pRoot == nullptr)
return nullptr;
return max(_pRoot);
}

//找到相同的键值获取（向下取）
Node* floor(const Key& key)
{
return floor(_pRoot, key);
}

//向上取
Node* ceiling(const Key& key)
{
return ceiling(_pRoot, key);
}

void deleteMin()
{
deleteMin(&_pRoot);
}

void deleteNodeByKey(const Key& key)
{
deleteNodeByKey(&_pRoot, key);
}

//某个区间内的所有节点
vector<Node*> getNodes
4000
ByKey(const Key& keyLo, const Key& keyHi)
{
vector<Node*> vet;
getNodesByKey(_pRoot, vet, keyLo, keyHi);
return vet;
}

private:  //实现
static void Destory(Node* pNode)
{
if(pNode == nullptr){
return;
}
Destory(pNode->_pLeft);
Destory(pNode->_pRight);
delete pNode;
}

static void getNodesByKey(Node* pNode, vector<Node*>& vet, const Key& keyLo, const Key& keyHi)
{
if (pNode == nullptr)
return;
int nLo = keyLo - pNode->_Key, nHi = keyHi - pNode->_Key;
if (nLo <= 0 && nHi >= 0) {
vet.push_back(pNode);
}
if (nLo < 0) getNodesByKey(pNode->_pLeft, vet, keyLo, keyHi); //说明键值还可以更小，需要继续往小的找
if(nHi > 0) getNodesByKey(pNode->_pRight, vet, keyLo, keyHi);//说明键值还可以更大
}

static void deleteMin(Node** ppNode)
{
vector<Node*> arrEachNode;        //之前遍历的节点 用于更新节点值
while (*ppNode) {
if ((*ppNode)->_pLeft == nullptr) { //没有左节点 说明该节点为最小
Node* pTmp = (*ppNode)->_pRight;
delete (*ppNode);                 //删除节点
*ppNode = pTmp;
//在这里遍历方向并不是重点
for (auto it = arrEachNode.rbegin(); it != arrEachNode.rend(); ++it) {
--((*it)->_n);
}
break;
}
arrEachNode.push_back(*ppNode);     //走过的节点
ppNode = &((*ppNode)->_pLeft);
}
}

//弹出一个最小的node
static Node* popMinNode(Node** ppNode)
{
vector<Node*> arrEachNode;        //之前遍历的节点 用于更新节点值
while (*ppNode) {
if ((*ppNode)->_pLeft == nullptr) { //没有左节点 说明该节点为最小
Node* pTmp = *ppNode;             //保存弹出的节点
*ppNode = (*ppNode)->_pRight;
//在这里遍历方向并不是重点
for (auto it = arrEachNode.rbegin(); it != arrEachNode.rend(); ++it) {
--((*it)->_n);
}
pTmp->_pLeft = pTmp->_pRight = nullptr;
pTmp->_n = 1;
return pTmp;
}
arrEachNode.push_back(*ppNode);     //走过的节点
ppNode = &((*ppNode)->_pLeft);
}
return nullptr;
}
/*
//删除一个节点，需要遍历走过的节点，重新计算值
static void deleteNode(Node** ppNode, vector<Node*>& arr)
{

}
*/
static void deleteNodeByKey(Node** ppNode, const Key& key)
{
vector<Node*> arrEachNode;        //之前遍历的节点 用于更新节点值
while (1) {
if (*ppNode == nullptr)         //找不到就走人
return;
arrEachNode.push_back(*ppNode); //记录
int nNum = key - (*ppNode)->_Key;
if (nNum < 0) ppNode = &((*ppNode)->_pLeft);
else if (nNum > 0) ppNode = &((*ppNode)->_pRight);
else {  //找到了
Node* pTmp = nullptr;
//之前走过的路都要减1
for (auto it = arrEachNode.rbegin(); it != arrEachNode.rend(); ++it) {
--((*it)->_n);
}
int nSwitch = 0;    //用于判断是否有孩子节点为空 如果有为空 直接将另外的孩子赋值到该节点上即可
if ((*ppNode)->_pLeft == nullptr) nSwitch = 1;
else if((*ppNode)->_pRight == nullptr) nSwitch = 2;
if (nSwitch != 0) {
if (nSwitch == 1) pTmp = (*ppNode)->_pRight;  //没有左孩子 可以直接将右孩子赋予节点
else if (nSwitch == 2) pTmp = (*ppNode)->_pLeft;
//else assert(0 && "nSwitch");
delete (*ppNode);                 //删除节点
//在这里并不需要重新计算该节点的值，因为孩子节点的值已经确定了下来，另外的孩子节点是null 所以并不需要更新
*ppNode = pTmp;
return;
}
pTmp = popMinNode(&((*ppNode)->_pRight));
pTmp->_pRight = (*ppNode)->_pRight;
pTmp->_pLeft = (*ppNode)->_pLeft;
delete (*ppNode);
pTmp->_n = 1;     //重新计算节点的值，因为2个孩子的值并不确定所以需要更新。
if (pTmp->_pLeft) pTmp->_n += pTmp->_pLeft->_n;
if (pTmp->_pRight) pTmp->_n += pTmp->_pRight->_n;
*ppNode = pTmp;
return;
}
}
}

static Node* min(Node* pNode)
{
while (pNode->_pLeft) {
pNode = pNode->_pLeft;
}
return pNode;
}

static Node* max(Node* pNode)
{
while (pNode->_pRight) {
pNode = pNode->_pRight;
}
return pNode;
}

static Node* ceiling(Node* pNode, const Key& key)
{
while (pNode) {
int nNum = key - pNode->_Key;
if (nNum > 0) pNode = pNode->_pRight;    //给定的key大于当前根节点 只能往右找大值了。
else if (nNum == 0) break;              //找到break
//key小于当前根节点 说明 只能往左找 找接近于key的值 如果找不到说明就是这个值了（向上取）
else {
Node* pTmp = floor(pNode->_pLeft, key);
if (pTmp)
pNode = pTmp;
break;
}
}
return pNode;
}

static Node* floor(Node* pNode, const Key& key)
{
while (pNode) {
int nNum = key - pNode->_Key;
if (nNum < 0) pNode = pNode->_pLeft;    //给定的key小于当前根节点 只能往左找小值了。
else if (nNum == 0) break;              //找到break
//key大于当前根节点 说明 只能往右找 找接近于key的值 如果找不到说明就是这个值了（向下取）
else {
Node* pTmp = floor(pNode->_pRight, key);
if (pTmp)
pNode = pTmp;
break;
}
}
return pNode;
}

static void put(Node** ppNode, const Key& key, const Value& value)
{
vector<Node*> arrEachNode;        //之前遍历的节点 用于更新节点值
while (1) {
if (*ppNode == nullptr) {
*ppNode = new Node(key, value, 1);
//在这里遍历方向并不是重点
for (auto it = arrEachNode.rbegin(); it != arrEachNode.rend(); ++it) {
++((*it)->_n);
}
return;
}
arrEachNode.push_back(*ppNode);
int nNum = key - (*ppNode)->_Key;
if (nNum < 0) ppNode = &((*ppNode)->_pLeft);
else if (nNum > 0) ppNode = &((*ppNode)->_pRight);
else {
(*ppNode)->_Value = value;
return;
}
}
}

static Node* get(Node* pNode, const Key& key)
{
while (pNode) {
int nNum = key - pNode->_Key;
if (nNum < 0) pNode = pNode->_pLeft;
else if (nNum > 0) pNode = pNode->_pRight;
else break;
}
return pNode;
}

private:
Node* _pRoot;
};