Recherche d'un arbre de recherche binaire - Based Array

voix
1

Je suis en train de rechercher un mot en utilisant une valeur clé récursive. En fonction de récupérer: Le problème est l'indice va de 0, 1,3,7, à 15 .... il suppose d'aller 0,1,3,7,8 et ainsi de suite je l'insert de travail comme prévu. Je le afinde, les précommandes, tout travail. Quelqu'un peut-il s'il vous plaît me aider à ce problème? Je travaille sur cette question depuis 4 jours maintenant! Je comprends qu'il va de gauche à droite. Le problème est qu'il ne regretterez pas juste après gauche. Je vais ajouter que les fonctions et le code je pense que vous aurez besoin pour me aider .. J'utilise 2 retireve pour faire une récursif ..

bool BST::retrieve(const char *key, data& aData) const
{

retrieve(key, aData, parent);

if (key == aData)
{
    return true;
}
else
{
    return false;
}

}

l'autre récupérer

bool BST::retrieve(const char *key, data &aData, int parent) const
{


if (!items[parent].empty )
{

    if (key == items[parent].instanceData.getName())
    {
        aData.setName(key);
        return true;
    }
    else if (key < items[parent].instanceData.getName() ) // changed -- now goes from 0,2,6 suppose to go to o,2,5
    {
        parent =(2*parent) + 1;
        retrieve(key, aData, parent);
    }
    else
    {
        parent =( 2*parent) + 2;
        retrieve(key, aData, parent);
    }
//  return 0;

} 
}

== Fonction opérateur ..

bool operator== (const data& d1, const data& d2)
{

return strcmp(d1.getName(), d2.getName()) == 0;

}

et voici un de mes fichiers d'en-tête ..

 #include data.h

 class BST                               
 {
 public:
BST(int capacity = 5);              // constructor (default if no arg supplied)
BST(const BST& aTable);             // copy constructor
~BST();                             // destructor

void insert(const data& aData);     
bool remove(const char *key);
bool retrieve(const char *key, data& aData) const;
void displayArrayOrder(ostream& out) const;     
void displayPreOrder(ostream& out) const;
void displayInOrder(ostream& out) const;
void displayPostOrder(ostream& out) const;
int getSize(void) const;

    private:

  int size;
  int maxsize;  
  int parent;


  void expand();

struct item
{
    bool    empty;
    data instanceData;
    bool  isLeaf;
};

item *items;

void insert(int index, const data & aData ); 
void displayHeaders(ostream& out)const;
void BST::displayPreOrder(std::ostream &out, int parent)const;
void BST::displayInOrder(std::ostream &out, int parent)const;
void BST::displayPostOrder(std::ostream &out, int parent)const;
bool BST::retrieve(const char *key, data& aData, int parent) const;
void itemsPrinted(ostream &out,int size)const;
  };


 #endif // BST_H

une partie de la fonction main () ..

database.insert(data(Ralston, Anthony));
database.insert(data(Liang, Li));
database.insert(data(Jones, Doug));
database.insert(data(Goble, Colin));
database.insert(data(Knuth, Donald));
database.insert(data(Kay, Alan));
database.insert(data(Von Neumann, John));
database.insert(data(Trigoboff, Michael));
database.insert(data(Turing, Alan));
displayDatabase(true);
    retrieveItem(Trigoboff, Michael, aData);
retrieveItem(Kaye, Danny, aData);    // calls search function..

et

bool operator< (const data& d1, const data& d2)
{

return strcmp(d1.getName(), d2.getName()) < 0;


}
Créé 06/12/2009 à 21:03
source utilisateur
Dans d'autres langues...                            


1 réponses

voix
2

il suppose d'aller 0,1,3,7,8

Pourquoi attendez-vous ce comportement? Ce n'est pas une recherche « binaire » du tout. L'enfant de gauche 7 sera 15, l'enfant droit sera 16. 8 est l'enfant droit de 3.

Votre code semble correct. Vos résultats semblent corrects. Il est à vos attentes qui semblent défectueux.

Créé 06/12/2009 à 21:09
source utilisateur

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