二叉搜尋樹簡單介紹

二叉搜尋樹(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