如何为允许在 C++ 中重复的复杂类型创建二叉搜索树？

Question

我已经阅读了很多关于 BST 和重复的帖子，并且我知道允许重复是不太可能/没有干净的方法，尤其是对于我正在使用的复杂类型。因此，我需要一些帮助，了解如何/是否可以在我的场景中实现具有重复项的 BST。

我的场景： 我使用事务类作为我的节点键，我比较的主要数据是事务类中的“金额”，所以我的二叉搜索树可以让您输入一个金额并使用它的“toString()”输出任何交易' 对用户的功能，与搜索量相匹配。但是，现在我面临无法重复交易金额的问题。我该如何解决这个问题？谁能提供一个例子？谢谢。

重现要解决的问题的代码：

#include<iostream>
using namespace std;
#include <algorithm>
#include <cctype>
#include <string>
#include <memory>

// Complex type used for the BST
class Transaction
{
private:
    std::string desc;
    time_t timestamp;
    std::string value;
    bool isWithdrawal;

public:

    Transaction(const std::string& value, std::string reason = "None.")
    : desc(reason), timestamp(time(nullptr)), value(value) { // timestamp is current date/time based on current system

        // Lambda to convert reason to lower to we can identify elements easier
        std::transform(reason.begin(), reason.end(), reason.begin(),
            [](unsigned char c) { return std::tolower(c); });
    
        this->isWithdrawal = (reason.find("withdrawal") != std::string::npos) ? true : false;
    } 

    std::string toString() const {
        // convert timestamp to string form
        const char* string_timestamp = ctime(&timestamp);
    
        if(this->isWithdrawal) { return "-- " + desc + ": -£" + value + " on " + string_timestamp;}
        else {return "-- " + desc + ": £" + value + " on " + string_timestamp;}
    }
    
    // Gets the amount, converts it to a double and returns it
    double getAmount() const {
        return std::stod(this->value);
    }
};


// The binary search tree implementation
class BST {
    
    struct node {
        std::shared_ptr<Transaction> data;
        node* left;
        node* right;
    };

    node* root;

    node* makeEmpty(node* t) {
        if(t == NULL)
            return NULL;
        {
            makeEmpty(t->left);
            makeEmpty(t->right);
            delete t;
        }
        return NULL;
    }

    node* insert(std::shared_ptr<Transaction> x, node* t)
    {
        if(t == NULL)
        {
            t = new node;
            t->data = x;
            t->left = t->right = NULL;
        }
        else if(x->getAmount() < t->data->getAmount())
            t->left = insert(x, t->left);
        else if(x->getAmount() > t->data->getAmount())
            t->right = insert(x, t->right);
        return t;
    }

    node* findMin(node* t)
    {
        if(t == NULL)
            return NULL;
        else if(t->left == NULL)
            return t;
        else
            return findMin(t->left);
    }

    node* findMax(node* t) {
        if(t == NULL)
            return NULL;
        else if(t->right == NULL)
            return t;
        else
            return findMax(t->right);
    }

    void inorder(node* t) {
        if(t == NULL)
            return;
        inorder(t->left);
        cout << t->data->getAmount() << " ";
        inorder(t->right);
    }

    node* find(node* t, double x) {
        if(t == NULL)
            return NULL;
        else if(x < t->data->getAmount())
            return find(t->left, x);
        else if(x > t->data->getAmount())
            return find(t->right, x);
        else
            return t;
    }

public:
    BST() {
        root = NULL;
    }

    ~BST() {
        root = makeEmpty(root);
    }

    void insert(std::shared_ptr<Transaction> x) {
        root = insert(x, root);
    }

    void display() {
        inorder(root);
        cout << endl;
    }

    std::string search(double x) {
        node* result = find(root, x);
        if(result != NULL) { return result->data->toString(); }
        else { return "N/A"; }
    }
};

int main() {
    BST t;
    t.insert(std::make_shared<Transaction>("1500.50", "Deposit"));
    t.insert(std::make_shared<Transaction>("1600.98", "Deposit"));
    t.insert(std::make_shared<Transaction>("1400", "Withdrawal"));
    t.insert(std::make_shared<Transaction>("1400.59", "Deposit"));
    t.display();
    
    std::cout << t.search(1500.50);
    
    return 0; 
}

Answer 1

我已经阅读了很多关于 BST 和重复的帖子，并且我知道允许重复是不太可能/没有干净的方法，尤其是对于我正在使用的复杂类型。

这是不正确的，您可以在这种情况下使用multimap or multiset。

例如，cppreference

Multimap 是一个关联容器，其中包含键值对的排序列表，同时允许具有相同键的多个条目。排序是根据比较函数比较完成的，应用于键。搜索、插入和删除操作具有对数复杂度。

您只需提供一个 Compare 函子作为模板参数，它表示对于两个等效键，没有一个小于另一个。

Answer 2

您可以通过使您的data 成员成为容器来将BST 节点与多个值相关联，例如，更改：

std::shared_ptr<Transaction> data;

进入

std::list<std::shared_ptr<Transaction>> data;

这与将一个键与多个值关联起来是一回事。本质上，这就是std::multimap 和std::multiset 所做的。您还必须更新树操作/迭代器。例如，在进行容器遍历时，您必须将单个 std::lists 压缩在一起。

编辑：

一个简单的替代方法是使用std::multiset<std::tuple<std::string, time_t, std::string, bool>>。

Answer 3

二叉搜索树可让您存储键和相关记录。它允许有效地搜索给定的键（目的是检索相关信息）。

由于它还支持按排序顺序枚举，它允许检索给定范围内的所有键，重复键不是问题。