Implementeren van een kaart van strings

stemmen
0

Ik heb een klasse die zich gedraagt ​​als een kaart van strings met behulp van binaire zoekboom te implementeren. Dit is de klasse I uitgevoerd:

template<class T>
class StringMapper {
private:
    // Pair
    struct Pair {
        std::string el1;
        T el2;
    };

    // Nod
    struct Node {
        Pair* data;
        Node* left;
        Node* right;
        Node()
        {
            data = new Pair;
        }
        ~Node()
        {
            delete data;
        }
        int nod_size()
        {
             // code here
        }
    };
    Node* root;
public:
    StringMapper()
    {
        root = 0;
    }
    ~StringMapper() {}
    void insert(std::string from, const T& to)
    {
        // code here
    }

    bool find(std::string from,const T& to) const
    {
        return find(root, to);
    }

    bool find(Node* node, const T& value) const
    {
        // code here
    }

    bool getFirstPair(std::string& from, T& to)
    {
        if(root != 0)
        {
            from = root->data->el1;
            to = root->data->el2;
            return true;
        }
        return false;
    }
    bool getNextPair(std::string& from, T& to)
    {
        if(root != 0)
        {

        }
        return false;
    }

    int size() const
    {
        return root->nod_size();
    }
};

Om eerlijk te zijn ik weet niet hoe u de functie uit te voeren getNextPair().
Als iemand me kon helpen zou ik het op prijs stellen.

De vraag is gesteld op 06/03/2011 om 22:13
bron van user
In andere talen...                            


2 antwoorden

stemmen
1

Uw interface is een interne iterator. Je moet een soort van pointer naar de plaats waar u zich in de iteratie in getFirstPair te houden, en stel deze in ().

Zodra u dit toe te voegen, getNextPair () gaat alleen maar om de volgende. Het is een beetje moeilijk om dit te doen, maar dat is je opdracht, dus ik laat het aan jou.

De werkelijke std::mapmaakt gebruik van een externe iterator - dat de toestand van de iteratie los van de datastructuur houdt. Het grote voordeel is de mogelijkheid om meer dan één gelijktijdige iteratie hebben.

antwoordde op 06/03/2011 om 22:22
bron van user

stemmen
1

Zonder gewoon het gooien van de algoritme voor het getNextPair, moet u een soort van interne iterator die zal verwijzen naar de "huidige" pair te houden. Zodra je dat, met het oog op het algoritme cijfer voor het volgende paar trek jezelf een boom met een aantal knooppunten en te zien hoe men het volgende knooppunt in de boom gegeven een willekeurig knooppunt in de boom te vinden.

antwoordde op 06/03/2011 om 22:46
bron van user

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more