二叉查找树

复习一下二叉查找树, 采用C++来编写。

将节点结构将其作为二叉查找树特用的,定义在类的内部里。

（贴代码的时候我是按照顺序贴的）

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*> getNodesByKey(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;
 };

总结： 删除节点的实现，要注意细节，三种遍历方式需要熟悉。