利用BST实现一个城市数据库

Task

1. 利用BST实现一个城市数据库：每个数据库结点包括城市名称和以整数x与y表示的城市坐标，根据城市名称组织该BST；
2. 在该数据库上实现按城市名称进行的插入、删除和检索；
3. 打印出以指定字母打头的所有城市记录；
4. 打印出与指定点的距离在给定值之内的所有城市记录；

Feature

1. 重用性强，BST类未对本项目进行针对性设计。
2. Select功能使用函数指针实现命中检测。
3. 树支持左旋，右旋操作，平衡通过DSW算法实现。
4. DB使用模拟指令进行数据操作，支持"remove",“insert”,“selectKey”,“selectLocation”,“print”,"balance"指令，输入命令为”cmd”时，即进入CIN流读取命令模式
5. 尝试使用AA树来实现，但由于自平衡后的树结构发生改变，中序输出时无法通过OJ的判题，于是放弃，在数据库中加入手动平衡指令。
6. 数据库类协作图
   

Code

BST（With balance function）

/**
 * @File     Bst.h
 * @Desc     传统二叉搜索树实现
 * @Date     19-4-20 下午6:42
 * @Author   Clifford A. Shaffer && Loopy
 * @ApiDoc   http://api.loopy.tech/api/bst/index.html
 * @Contact  57658689098a@gmail.com
 * @Software CLion
 */
#ifndef BST_BST_H
#define BST_BST_H
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
/**
 * @brief 二叉搜索树的节点
 */
template <typename Key, typename E>
class BSTNode
{
   
private:
    Key k;       /**< 节点的key */
    E it;        /**< 节点数据 */
    BSTNode *lc; /**< 节点的左孩子 */
    BSTNode *rc; /**< 节点的右孩子 */

public:
    /** 缺省构造函数 */
    BSTNode() {
    lc = rc = nullptr; }

    /** 带初始值的构造函数
    *
    *     @param K 节点的key
    *     @param e 节点数据
    *     @param l (可缺)节点的左孩子
    *     @param r (可缺)节点的右孩子
    */
    BSTNode(Key K, E e, BSTNode *l = nullptr, BSTNode *r = nullptr)
    {
   
        k = K;
        it = e;
        lc = l;
        rc = r;
    }

    /** 缺省析构函数 */
    ~BSTNode() = default; // Destructor

    /** 查-数据 */
    E &element() {
    return it; }

    /** 改-数据 */
    void setElement(const E &e) {
    it = e; }

    /** 查-键值 */
    Key key() {
    return k; }

    /** 改-键值 */
    void setKey(Key K) {
    k = K; }

    /** 查-左孩子 */
    inline BSTNode *left() const {
    return lc; }

    /** 改-左孩子 */
    void setLeft(BSTNode<Key, E> *b) {
    lc = (BSTNode *)b; }

    /** 查-右孩子 */
    inline BSTNode *right() const {
    return rc; }

    /** 改-右孩子 */
    void setRight(BSTNode<Key, E> *b) {
    rc = (BSTNode *)b; }

    /** 是否为叶子 */
    bool isLeaf() {
    return (lc == nullptr) && (rc == nullptr); }
};

/**
 * @brief 二叉搜索树
 */
template <typename Key, typename E>
class BST
{
   
private:
    BSTNode<Key, E> *root; /**< 二叉搜索树的根节点 */
    int nodecount;         /**< 二叉搜索树的节点数 */

    // Private "helper" functions
    /** 删除某一节点及其子孙 */
    void clearhelp(BSTNode<Key, E> *root)
    {
   
        if (root == nullptr)
            return;
        clearhelp(root->left());
        clearhelp(root->right());
        delete root;
    };

    /** 寻找位点以插入节点
    *
    *     @param root 待插入区域的祖先
    *     @param k 待插入的节点的键
    *     @param it 待插入的节点
    *     @return root 待插入区域的祖先
    */
    BSTNode<Key, E> *inserthelp(BSTNode<Key, E> *root, const Key &k, const E &it)
    {
   
        if (root == nullptr) // Empty tree: create node
            return new BSTNode<Key, E>(k, it, nullptr, nullptr);
        if (k < root->key())
            root->setLeft(inserthelp(root->left(), k, it));
        else
            root->setRight(inserthelp(root->right(), k, it));
        return root; // Return tree with node inserted
    }

    /** 寻找最小节点
    *
    *     @param rt 待寻区域的最大深度祖先
    *     @return 最小节点
    */
    BSTNode<Key, E> *getmin(BSTNode<Key, E> *rt)
    {
   
        if (rt->left() == nullptr)
            return rt;
        else
            return getmin(rt->left());
    }

    /** 删除最小节点
    *
    *     @param rt 待寻区域的最大深度祖先
    *     @return 最小节点
    */
    BSTNode<Key, E> *deletemin(BSTNode<Key, E> *rt)
    {
   
        if (rt->left() == nullptr) // Found min
            return rt->right();
        else
        {
    // Continue left
            rt->setLeft(deletemin(rt->left()));