二叉搜索树(Binary Search Tree)的递归和非递归代码实现(C++)

二叉搜索树简单介绍

二叉搜索树(Binary Search Tree)是满足：

• 左子树的根节点比树的根节点小
• 右子树的根节点比树的根节点大
  的二叉树。

由于这种数据结构具有很高的查询效率，故多用于需要索引的场合。

二叉搜索树的搜索过程可以理解成类二分查找，因为根节点就等效于一串数据的分界点，左子树的所有节点都小于根节点，右子树的所有节点都大于根节点，然后每次比较都能确定元素属于哪一部分，故查询效率为O(nlogn)。

查找

根据二叉搜索数的性质有：

• 大于节点key的元素在右子树
• 小于节点key的元素在左子树

在二叉搜索树中查找指定元素 k（node表示当前搜索节点）：

• 递归思路：
  若 k > node->key，搜索 node->rNode
  若 k < node->key，搜索 node->lNode
  若 k = node->key，返回 node->val
• 非递归思路
  设置一个用来遍历节点的指针p
  若 k > p->key，p = p->rNode
  若 k < p->key，p = p->lNode
  若 k = p->key，返回 p->val

插入

首先需要寻找到插入位置，在寻找位置的过程中如果发现有相同key则更新该key对应的value，否则插入新的节点
- 递归思路：
递归出口：node = NULL，创建新节点并用 key 和 val 初始化
若 k > node->key，node->lNode = put(node->lNode, key)
若 k < node->key，node->rNode = put(node->rNode, key)
若 k = node->key，node->val = val
当前节点个数 = 左子树节点个数 + 右子树节点个数 + 1
- 非递归思路：
设置一个堆栈和遍历指针 p，p 的父节点指针 pa
将经过的节点都记录到堆栈中，如果找到重复节点则更新值并清空堆栈。
否则新建节点并用 key 和 val 初始化，并将 pa 指向 p，同时栈中所有节点的节点个数 N 增加1

删除

• 递归思路：
  和插入类似，只是在key = node->key的时候需要分情况：
  若 node->rNode 不为空，则找到 node->rNode 子树的最小节点min并将node->key = min->key，node->val = min->val，然后删除该最小节点
  若 node->rNode 为空，node->lNode 不为空，则直接 node = node ->lNode
  若 node->rNode 为空，node->lNode 为空，则直接 node = NULL
• 非递归思路：
  和递归类似，只是需要遍历堆栈去更新遍历路径上的节点数 N

代码实现

递归版本

//BSTR.h
#ifndef BSTR_H
#define BSTR_H

#include <iostream>
template<typename K, typename V>
struct Node
{
    K key;
    V val;
    int N;
    Node<K,V>* lNode;
    Node<K,V>* rNode;
    Node()
    {
        this->lNode = NULL;
        this->rNode = NULL;
    }
    Node(K key, V val)
    {
        this->key = key;
        this->val = val;
        this->lNode = NULL;
        this->rNode = NULL;
        this->N = 1;
    }
};

template<typename K, typename V>
class BST
{
public:
    BST();
    ~BST();
    V get(const K& key) const;
    void put(const K& key, const V& val);
    void del(const K& key);
    bool contain(const K& key) const;
    int size() const;
    void clean();
    void print() const;

    K floor(const K& key) const;
    K celling(const K& key) const;
    int rank(const K& key) const;
    K select(int rk) const;
    K minKey() const;
    K maxKey() const;
    void delMin();
    void delMax();
protected:
    Node<K,V>* root;

    V get(Node<K,V>* node, const K& key) const;
    void clean(Node<K,V>* node);
    Node<K,V>* put(Node<K,V>* node, const K& key, const V& val);
    Node<K,V>* del(Node<K,V>* node, const K& key);
    bool contain(Node<K,V>* node, const K& key) const;
    int size(Node<K,V>* node) const;
    void print(Node<K,V>* node) const;
    K floor(Node<K,V>* node, const K& key) const;
    K celling(Node<K,V>* node, const K& key) const;
    int rank(Node<K,V>* node, const K& key) const;
    K select(Node<K,V>* node, int rk) const;
    K minKey(Node<K,V>* node) const;
    K maxKey(Node<K,V>* node) const;
    Node<K,V>* delMin(Node<K,V>* node);
    Node<K,V>* delMax(Node<K,V>* node);

};

//构造 析构函数
template<typename K, typename V>
BST<K,V>::BST()
{
    this->root = NULL;
}
template<typename K, typename V>
BST<K,V>::~BST()
{
    if (this->root != NULL)
        clean(this->root);
}

/******************************************************************** 
函数名称:   clean
函数说明:   清空表
返回值:    无 
*********************************************************************/
template<typename K, typename V>
void BST<K,V>::clean()
{
    clean(this->root);
    this->root = NULL;
}

template<typename K, typename V>
void BST<K,V>::clean(Node<K,V>* node)
{
    if (node == NULL)
        return ;
    clean(node->lNode);
    clean(node->rNode);
    delete node;
}

/******************************************************************** 
函数名称:   size
函数说明:   无
返回值:     表的大小
*********************************************************************/
template<typename K, typename V>
int BST<K,V>::size() const
{
    return size(this->root);
}

template<typename K, typename V>
int BST<K,V>::size(Node<K,V>* node) const
{
    if (node != NULL)
        return node->N;
    else
        return 0;
}
/******************************************************************** 
函数名称:   put
函数说明:   放入键值对<key,value> 若存在则将原有的value替换成新的value
返回值:     无
*********************************************************************/
template<typename K, typename V>
void BST<K,V>::put(const K& key, const V& val)
{
    this->root = put(this->root, key, val);
}

template<typename K, typename V>
Node<K,V>* BST<K,V>::put(Node<K,V>* node, const K& key, const V& val)
{
    if (node == NULL)
        return new Node<K,V>(key ,val);
    if (key > node->key)
        node->rNode = put(node->rNode, key, val);
    else if (key < node->key)
        node->lNode = put(node->lNode, key, val);
    else
        node->val = val;
    node->N = size(node->lNode) + size(node->rNode) + 1;
    return node;
}

/******************************************************************** 
函数名称:   get
函数说明:   获取指定key的value
返回值:     value
*********************************************************************/
template<typename K, typename V>
V BST<K,V>::get(const K& key) const
{
    return get(this->root, key);
}

template<typename K, typename V>
V BST<K,V>::get(Node<K,V>* node, const K& key) const
{
    if (node == NULL)
        return NULL;
    if (key > node->key)
        return get(node->rNode, key);
    else if (key < node->key)
        return get(node->lNode, key);
    else
        return node->val;
}
/******************************************************************** 
函数名称:   del
函数说明:   删除某个key
返回值:     无
*********************************************************************/
template<typename K, typename V>
void BST<K,V>::del(const K& key)
{
    this->root = del(this->root, key);
}

template<typename K, typename V>
Node<K,V>* BST<K,V>::del(Node<K,V>* node, const K& key)
{
    if (node == NULL)
        return NULL;
    if (key > node->key)
        node->rNode = del(node->rNode, key);
    else if (key < node->key)
        node->lNode = del(node->lNode, key);
    else
    {
        Node<K,V>* newNode;
        if (node->lNode == NULL && node->rNode == NULL)
            return NULL;
        else if (node->lNode != NULL && node->rNode == NULL)
        {
            newNode = node->lNode;
            delete node;
            node = newNode;
        }
        else if (node->lNode == NULL && node->rNode != NULL)
        {
            newNode = node->rNode;
            delete node;
            node = newNode;
        }
        else
        {
            node->key = minKey(node->rNode);
            node->val = get(node->key);
            node->rNode = delMin(node->rNode);
        }
    }
    node->N = size(node->lNode) + size(node->rNode) + 1;
    return node;
}
/******************************************************************** 
函数名称:   print
函数说明:   打印表中内容
返回值:     无
*********************************************************************/
template<typename K, typename V>
void BST<K,V>::print() const
{
    print(this->root);
}
template<typename K, typename V>
void BST<K,V>::print(Node<K,V>* node) const
{
    if (node == NULL)
        return;
    print(node->lNode);
    std::cout << node->key << ":" << node->val << " : " << node->N << std::endl;
    print(node->rNode);
}

/******************************************************************** 
函数名称:   contain
函数说明:   是否包含key
返回值:     包含返回true 不包含返回false
*********************************************************************/
template<typename K, typename V>
bool BST<K,V>::contain(const K& key) const
{
    return contain(this->root, key);
}
template<typename K, typename V>
bool BST<K,V>::contain(Node<K,V>* node, const K& key) const
{
    if (node == NULL)
        return false;
    if (key > node->key)
        contain(node->rNode, key);
    else if (key < node->key)
        contain(node->lNode, key);
    else
        return true;
}

/******************************************************************** 
函数名称:  floor
函数参数： key
函数说明:  寻找表中小于等于key的最大key
返回值:    key
*********************************************************************/
template<typename K, typename V>
K BST<K,V>::floor(const K& key) const
{
    return floor(this->root, key);
}
template<typename K, typename V>
K BST<K,V>::floor(Node<K,V>* node, const K& key) const
{
    static K mKey;
    if (node == NULL)
        return mKey;
    if (key > node->key)
    {
        mKey = node->key;
        floor(node->rNode, key);
    }
    else if (key < node->key)
        floor(node->lNode, key);
    else
        return node->key;
}

/******************************************************************** 
函数名称:  celling
函数参数： key
函数说明:  寻找表中大于等于key的最小key
返回值:    key
*********************************************************************/
template<typename K, typename V>
K BST<K,V>::celling(const K& key) const
{
    return celling(this->root, key);
}
template<typename K, typename V>
K BST<K,V>::celling(Node<K,V>* node, const K& key) const
{
    static K mKey;
    if (node == NULL)
        return mKey;
    if (key > node->key)
        celling(node->rNode, key);
    else if (key < node->key)
    {
        mKey = node->key;
        celling(node->lNode, key);
    }
    else
        return node->key;
}

/******************************************************************** 
函数名称:  rank
函数参数： key的值
函数说明:  在表中找出小于等于key值的元素个数
返回值:    key的个数
*********************************************************************/
template<typename K, typename V>
int BST<K,V>::rank(const K& key) const
{
    return rank(this->root, key);
}
template<typename K, typename V>
int BST<K,V>::rank(Node<K,V>* node, const K& key) const
{
    if (node == NULL)
        return 0;
    if (key >= node->key)
        return size(node->lNode) + 1 + rank(node->rNode, key);
    else
        return rank(node->lNode, key);
}

/******************************************************************** 
函数名称:  select
函数参数： 元素个数
函数说明:  在表中按从小到大的顺序找出第 k 个key
返回值:    key
*********************************************************************/
template<typename K, typename V>
K BST<K,V>::select(int rk) const
{
    return select(this->root, rk);
}
template<typename K, typename V>
K BST<K,V>::select(Node<K,V>* node, int rk) const
{
    int N;
    if (rk > this->root->N)
        rk = this->root->N;
    if (node->lNode != NULL)
        N = node->lNode->N;
    else
        N = 0;
    if (rk <= N)
        return select(node->lNode, rk);
    else if (rk == (N + 1))
        return node->key;
    else
        return select(node->rNode, rk - N - 1);
}

/******************************************************************** 
函数名称:  minKey
函数参数： 无
函数说明:  返回表中最小的key
返回值:    key
*********************************************************************/
template<typename K, typename V>
K BST<K,V>::minKey() const
{   
    return minKey(this->root);
}
template<typename K, typename V>
K BST<K,V>::minKey(Node<K,V>* node) const
{
    if (node->lNode == NULL)
        return node->key;
    minKey(node->lNode);
}

/******************************************************************** 
函数名称:  maxKey
函数参数： 无
函数说明:  返回表中最大的key
返回值:    key
*********************************************************************/
template<typename K, typename V>
K BST<K,V>::maxKey() const
{   
    return maxKey(this->root);
}
template<typename K, typename V>
K BST<K,V>::maxKey(Node<K,V>* node) const
{
    if (node->rNode == NULL)
        return node->key;
    maxKey(node->rNode);
}

/******************************************************************** 
函数名称:  delMin
函数参数： 无
函数说明:  删除表中最小key
返回值:    无
*********************************************************************/
template<typename K, typename V>
void BST<K,V>::delMin()
{
    this->root = delMin(this->root);
}
template<typename K, typename V>
Node<K,V>* BST<K,V>::delMin(Node<K,V>* node)
{
    if (node->lNode == NULL)
    {
        Node<K,V>* rNode = node->rNode;
        delete node;
        return rNode;
    }
    else
        node->lNode = delMin(node->lNode);
    node->N = size(node->lNode) + size(node->rNode) + 1;
    return node;
}

/******************************************************************** 
函数名称:  delMax
函数参数： 无
函数说明:  删除表中最大key
返回值:    无
*********************************************************************/
template<typename K, typename V>
void BST<K,V>::delMax()
{
    this->root = delMax(this->root);
}
template<typename K, typename V>
Node<K,V>* BST<K,V>::delMax(Node<K,V>* node)
{
    if (node->rNode == NULL)
    {
        Node<K,V>* lNode = node->lNode;
        delete node;
        return lNode;
    }
    else
        node->rNode = delMax(node->rNode);
    node->N = size(node->lNode) + size(node->rNode) + 1;
    return node;
}

#endif

#endif

非递归版本

#ifndef BST_H
#define BST_H

#include <iostream>
#include <stack>

template<typename K, typename V>
struct Node
{
    K key;
    V val;
    int N;
    Node<K,V>* lNode;
    Node<K,V>* rNode;
    Node()
    {
        this->lNode = NULL;
        this->rNode = NULL;
        this->N = 1;
    }
    Node(K key, V val)
    {
        this->key = key;
        this->val = val;
        this->lNode = NULL;
        this->rNode = NULL;
        this->N = 1;
    }
};
template<typename K, typename V>
class BST : public ST<K,V>
{
public:
    BST();
    ~BST();
    V get(const K& key) const;
    void put(const K& key, const V& val);
    void del(const K& key);
    bool contain(const K& key) const;
    int size() const;
    void clean();
    void print() const;

    K floor(const K& key) const;
    K celling(const K& key) const;
    int rank(const K& key) const;
    K select(int rk) const;
    K minKey() const;
    K maxKey() const;
    void delMin();
    void delMax();
protected:
    Node<K,V>* root;

    std::stack<Node<K,V>*> *s; //辅助堆栈
    int size(Node<K,V>* node) const;
    void print(Node<K,V>* node) const;
    void insNode(Node<K,V>* node, Node<K,V>* theNode);
    Node<K,V>* findPos(Node<K,V>* node, const K& key) const;
};

//构造 析构函数
template<typename K, typename V>
BST<K,V>::BST()
{
    this->root = NULL;
    this->s = new std::stack<Node<K,V>*>;
}
template<typename K, typename V>
BST<K,V>::~BST()
{
    clean();
}

/******************************************************************** 
函数名称:   get
函数说明:   获取指定key的value
返回值:     value
*********************************************************************/
template<typename K, typename V>
V BST<K,V>::get(const K& key) const
{
    if (this->root == NULL)
        return NULL;
    Node<K,V>* tNode = findPos(this->root, key);
    if (tNode->key != key)
        return NULL;
    else
        return tNode->val;
}
/******************************************************************** 
函数名称:   put
函数说明:   放入键值对<key,value> 若存在则将原有的value替换成新的value
返回值:     无
*********************************************************************/
template<typename K, typename V>
void BST<K,V>::put(const K& key, const V& val)
{
    if (this->root == NULL)
        this->root = new Node<K,V>(key, val);
    else
    {
        Node<K,V>* tNode = findPos(this->root, key);
        if (tNode->key != key)
        {
            insNode(tNode, new Node<K,V>(key, val));
            while (!this->s->empty())
            {
                this->s->top()->N++;
                this->s->pop();
            }
        }
        else
        {
            tNode->val = val;
        }
    }
}

/******************************************************************** 
函数名称:   del
函数说明:   删除某个key
返回值:     无
*********************************************************************/
template<typename K, typename V>
void BST<K,V>::del(const K& key)
{
    Node<K,V> *parentNode = NULL, *currentNode = this->root;
    //清空堆栈
    while (!this->s->empty())
        this->s->pop();

    //寻找被删除的节点以及该节点的父节点
    while (currentNode != NULL)
    {
        if (key == currentNode->key)
            break;
        this->s->push(parentNode = currentNode);
        if (key > currentNode->key)
            currentNode = currentNode->rNode;
        else
            currentNode = currentNode->lNode;
    }

    //没有寻找到需要删除的节点
    if (currentNode == NULL)
        return ;
    if (currentNode == this->root) //删除的节点是根节点
    {
        if (currentNode->lNode == NULL)
            this->root = currentNode->rNode;
        else if (currentNode->rNode == NULL)
            this->root = currentNode->lNode;
        else
        {
            //把右子树插入左子树中
            insNode(findPos(this->root = currentNode->lNode, currentNode->rNode->key), currentNode->rNode);
            while (!this->s->empty())
            {
                this->s->top()->N += size(currentNode->rNode);
                this->s->pop();
            }
        }
    }
    else //删除的节点是非根节点
    {
        //父指针置 NULL
        if (currentNode == parentNode->lNode)
            parentNode->lNode = NULL;
        else
            parentNode->rNode = NULL;

        while (!this->s->empty())
        {
            this->s->top()->N -= size(currentNode);
            this->s->pop();
        }

        if (currentNode->lNode != NULL)
        {
            insNode(findPos(this->root, currentNode->lNode->key), currentNode->lNode);
            while (!this->s->empty())
            {
                this->s->top()->N += size(currentNode->lNode);
                this->s->pop();
            }
        }
        if (currentNode->rNode != NULL)
        {
            insNode(findPos(this->root, currentNode->rNode->key), currentNode->rNode);
            while (!this->s->empty())
            {
                this->s->top()->N += size(currentNode->rNode);
                this->s->pop();
            }
        }
    }
    delete currentNode;
}

/******************************************************************** 
函数名称:   size
函数说明:   无
返回值:     表的大小
*********************************************************************/
template<typename K, typename V>
int BST<K,V>::size() const
{
    return size(this->root);
}

template<typename K, typename V>
int BST<K,V>::size(Node<K,V>* node) const
{
    if (node == NULL)
        return NULL;
    return node->N;
}
/******************************************************************** 
函数名称:   clean
函数说明:   清空表 采用层序遍历
返回值:    无 
*********************************************************************/
template<typename K, typename V>
void BST<K,V>::clean()
{
    if (this->root == NULL)
        return ;
    int currentPos = 0, i = 0;
    int TSize = size();
    Node<K,V>** nodeList = new Node<K,V>*[TSize];
    nodeList[i++] = this->root;
    while (currentPos < TSize)
    {
        if (nodeList[currentPos]->lNode != NULL)
            nodeList[i++] = nodeList[currentPos]->lNode;
        if (nodeList[currentPos]->rNode != NULL)
            nodeList[i++] = nodeList[currentPos]->rNode;
        delete nodeList[currentPos];
        currentPos++;
    }
    delete[] nodeList;
    this->root = NULL;
}
/******************************************************************** 
函数名称:   print
函数说明:   打印表中内容
返回值:     无
*********************************************************************/
template<typename K, typename V>
void BST<K,V>::print() const
{
    //print(this->root);
    std::stack<Node<K,V>*> x;
    Node<K,V>* currentNode = this->root;
    //std::stack<Node<K,V>*> f;
    //中序遍历非递归
    while (1)
    {
        while (currentNode != NULL)
        {
            x.push(currentNode);
            currentNode = currentNode->lNode;
        }
        while (!x.empty() && x.top()->rNode == NULL)
        {
            std::cout << x.top()->key << " : " << x.top()->val << std::endl;
            x.pop();
        }
        if (x.empty())
            break;
        std::cout << x.top()->key << " : " << x.top()->val << std::endl;
        currentNode = x.top()->rNode;
        x.pop();
    }

    //前序遍历非递归
    //while (1)
    //{
    //   while (currentNode != NULL)
    //   {
    //       std::cout << currentNode->key << " : " << currentNode->val << std::endl;
    //       if (currentNode->rNode != NULL)
    //           x.push(currentNode->rNode);
    //       currentNode = currentNode->lNode;
    //   }
    //   if (x.empty())
    //       break;
    //   currentNode = x.top();
    //   x.pop();
    //}

    //后序遍历非递归
    //while (1)
    //{
    //  while (currentNode != NULL)
    //  {
    //      x.push(currentNode);
    //      currentNode = currentNode->lNode;
    //  }
    //  while (!x.empty() && x.top()->rNode == NULL)
    //  {
    //      std::cout << x.top()->key << " : " << x.top()->val << std::endl;
    //      x.pop();
    //  }
    //  while (!x.empty() && !f.empty() && x.top() == f.top())
    //  {
    //      std::cout << x.top()->key << " : " << x.top()->val << std::endl;
    //      x.pop();
    //      f.pop();
    //  }

    //  if (x.empty())
    //      break;

    //  if (x.top()->rNode != NULL)
    //      f.push(x.top());

    //  currentNode = x.top()->rNode;
    //}

}
template<typename K, typename V>
void BST<K,V>::print(Node<K,V>* node) const
{
    if (node == NULL)
        return;
    print(node->lNode);
    std::cout << node->key << ":" << node->val << "   " << node->N << std::endl;
    print(node->rNode);

}

/******************************************************************** 
函数名称:   contain
函数说明:   是否包含key
返回值:     包含返回true 不包含返回false
*********************************************************************/
template<typename K, typename V>
bool BST<K,V>::contain(const K& key) const
{
    return findPos(this->root, key)->key == key;
}

/******************************************************************** 
函数名称:   findPos
函数说明:   寻找 键值为key的节点 或 该节点插入树时父节点的位置
返回值:     指向该节点的指针
*********************************************************************/
template<typename K, typename V>
Node<K,V>* BST<K,V>::findPos(Node<K,V>* node, const K& key) const
{

    //递归版本
    //if (key > node->key)
    //{
    //  if (node->rNode == NULL)
    //      return node;
    //  else
    //      return findPos(node->rNode, key);
    //}
    //else if (key < node->key)
    //{
    //  if (node->lNode == NULL)
    //      return node;
    //  else
    //      return findPos(node->lNode, key);
    //}
    //else
    //  return node;
    //非递归
    if (this->root == NULL)
        return NULL;
    while (!this->s->empty())
        this->s->pop();

    while(1)
    {
        this->s->push(node);

        if (key > node->key)
        {
            if (node->rNode == NULL)
                return node;
            else
                node = node->rNode;
        }
        else if (key < node->key)
        {
            if (node->lNode == NULL)
                return node;
            else
                node = node->lNode;
        }
        else
            return node;
    }

}

/******************************************************************** 
函数名称:  insNode
函数参数： 插入节点和待插入节点
函数说明:  将一棵树插入另一棵树上
返回值:    无
*********************************************************************/
template<typename K, typename V>
void BST<K,V>::insNode(Node<K,V>* node, Node<K,V>* theNode)
{
    if (theNode->key > node->key)
        node->rNode = theNode;
    else
        node->lNode = theNode;
}

/******************************************************************** 
函数名称:  floor
函数参数： key
函数说明:  寻找表中小于等于key的最大key
返回值:    key
*********************************************************************/
template<typename K, typename V>
K BST<K,V>::floor(const K& key) const
{
    if (this->root == NULL)
        return NULL;
    Node<K,V>* currentNode = this->root;
    K mKey;
    while (currentNode != NULL)
    {
        if (key > currentNode->key)
        {
            mKey = currentNode->key;
            currentNode = currentNode->rNode;
        }
        else if (key < currentNode->key)
            currentNode = currentNode->lNode;
        else
            return currentNode->key;
    }
    return mKey;
}

/******************************************************************** 
函数名称:  celling
函数参数： key
函数说明:  寻找表中大于等于key的最小key
返回值:    key
*********************************************************************/
template<typename K, typename V>
K BST<K,V>::celling(const K& key) const
{
    if (this->root == NULL)
        return NULL;
    Node<K,V>* currentNode = this->root;
    K mKey;
    while (currentNode != NULL)
    {
        if (key > currentNode->key)
            currentNode = currentNode->rNode;
        else if (key < currentNode->key)
        {
            mKey = currentNode->key;
            currentNode = currentNode->lNode;
        }
        else
            return currentNode->key;
    }
    return mKey;
}

/******************************************************************** 
函数名称:  minKey
函数参数： 无
函数说明:  返回表中最小的key
返回值:    key
*********************************************************************/
template<typename K, typename V>
K BST<K,V>::minKey() const
{
    if (this->root == NULL)
        return NULL;
    Node<K,V>* currentNode = this->root;
    while (currentNode->lNode != NULL)
        currentNode = currentNode->lNode;
    return currentNode->key;
}

/******************************************************************** 
函数名称:  maxKey
函数参数： 无
函数说明:  返回表中最大的key
返回值:    key
*********************************************************************/
template<typename K, typename V>
K BST<K,V>::maxKey() const
{
    if (this->root == NULL)
        return NULL;
    Node<K,V>* currentNode = this->root;
    while (currentNode->rNode != NULL)
        currentNode = currentNode->rNode;
    return currentNode->key;
}

/******************************************************************** 
函数名称:  delMin
函数参数： 无
函数说明:  删除表中最小key
返回值:    无
*********************************************************************/
template<typename K, typename V>
void BST<K,V>::delMin()
{
    if (this->root == NULL)
        return ;

    while (!this->s->empty())
        this->s->pop();

    Node<K,V>* currentNode = this->root;
    while (currentNode->lNode != NULL)
    {
        this->s->push(currentNode);
        currentNode = currentNode->lNode;
    }

    if (currentNode->rNode != NULL)
        this->s->top()->lNode = currentNode->rNode;
    else
        this->s->top()->lNode = NULL;

    delete currentNode;

    while (!this->s->empty())
    {
        this->s->top()->N--;
        this->s->pop();
    }
}

/******************************************************************** 
函数名称:  delMax
函数参数： 无
函数说明:  删除表中最大key
返回值:    无
*********************************************************************/
template<typename K, typename V>
void BST<K,V>::delMax()
{
    if (this->root == NULL)
        return ;

    while (!this->s->empty())
        this->s->pop();

    Node<K,V>* currentNode = this->root;
    while (currentNode->rNode != NULL)
    {
        this->s->push(currentNode);
        currentNode = currentNode->rNode;
    }

    if (currentNode->lNode != NULL)
        this->s->top()->rNode = currentNode->lNode;
    else
        this->s->top()->rNode = NULL;

    delete currentNode;

    while (!this->s->empty())
    {
        this->s->top()->N--;
        this->s->pop();
    }
}

/******************************************************************** 
函数名称:  rank
函数参数： key的值
函数说明:  在表中找出小于等于key值的元素个数
返回值:    key的个数
*********************************************************************/
template<typename K, typename V>
int BST<K,V>::rank(const K& key) const
{
    if (this->root == NULL)
        return NULL;
    int num = 0;
    Node<K,V>* currentNode = this->root;
    while (currentNode != NULL)
    {
        if (key >= currentNode->key)
        {
            num += (size(currentNode->lNode) + 1);
            currentNode = currentNode->rNode;
        }
        else
            currentNode = currentNode->lNode;
    }
    return num;
}

/******************************************************************** 
函数名称:  select
函数参数： 元素个数
函数说明:  在表中按从小到大的顺序找出第 k 个key
返回值:    key
*********************************************************************/
template<typename K, typename V>
K BST<K,V>::select(int rk) const
{
    if (this->root == NULL)
        return NULL;
    Node<K,V>* currentNode = this->root;
    int num = rk;
    if (num > size())
        num = size();
    while(currentNode != NULL)
    {
        if (num == size(currentNode->lNode) + 1)
            return currentNode->key;
        else if (num > size(currentNode->lNode))
        {
            num -= (size(currentNode->lNode) + 1);
            currentNode = currentNode->rNode;
        }
        else
            currentNode = currentNode->lNode;
    }
    return NULL;
}
#endif