Actualmente tengo una configuración de árbol binario de búsqueda, utilizando las plantillas que me permita cambiar fácilmente el tipo de datos dentro del árbol de búsqueda binaria. Por el momento, estoy teniendo problemas para sobrecargar la clase studentRecord que contiene los datos que se almacenan en el árbol. Necesito a la sobrecarga de los operadores de comparación dentro de esta clase, por lo que mi BST puede comparar adecuadamente dos objetos basado en una de sus contenidos (en este caso, el estudiante ID). Sin embargo, a pesar de la sobrecarga de los operadores dentro studentRecord, las comparaciones adecuadas todavía no están produciendo.
Detalles abajo:
Por el momento, el objeto studentTree BST ha sido creado, de tipo
bst<studentRecord *> studentTree;
studentRecord es la siguiente clase:
// studentRecord class
class studentRecord{
public:
// standard constructors and destructors
studentRecord(int studentID, string lastName, string firstName, string academicYear){ // constructor
this->studentID=studentID;
this->lastName=lastName;
this->firstName=firstName;
this->academicYear=academicYear;
}
friend bool operator > (studentRecord &record1, studentRecord &record2){
if (record1.studentID > record2.studentID)
cout << Greater! << endl;
else
cout << Less then! << endl;
return (record1.studentID > record2.studentID);
}
private:
// student information
string studentID;
string lastName;
string firstName;
string academicYear;
};
Cada vez que se agregan nuevos elementos a mi BST, deben ser comparados entre sí. Por lo tanto, quería sobrecargar la clase studentRecord, de modo que cuando se produce este proceso de comparación, los studentIDs se comparan (de lo contrario, se hará una comparación no válido).
Sin embargo, mi función de inserción nunca usa mis funciones de comparación sobrecargados. En cambio, parece que la comparación de los dos objetos de alguna otra manera, lo que resulta en la clasificación no válida dentro del BST. Parte de mi función de inserción está por debajo de - es importante tener en cuenta que tanto los datos nodePtr-> toInsert y deben ser de tipo studentRecord, debido a la occuring proceso de plantillas.
// insert (private recursive function)
template<typename bstType>
void bst<bstType>::insert(bstType & toInsert, bstNodePtr & nodePtr){
// check to see if the nodePtr is null, if it is, we've found our insertion point (base case)
if (nodePtr == NULL){
nodePtr = new bst<bstType>::bstNode(toInsert);
}
// else, we are going to need to keep searching (recursive case)
// we perform this operation recursively, to allow for rotations (if AVL tree support is enabled)
// check for left
else if (toInsert < (nodePtr->data)){ // go to the left (item is smaller)
// perform recursive insert
insert(toInsert,nodePtr->left);
// AVL tree sorting
if(getNodeHeight(nodePtr->left) - getNodeHeight(nodePtr->right) == 2 && AVLEnabled)
if (toInsert < nodePtr->left->data)
rotateWithLeftChild(nodePtr);
else
doubleRotateWithLeftChild(nodePtr);
}
Además, aquí es una parte de la clase Defintion BST
// BST class w/ templates
template <typename bstType>
class bst{
private: // private data members
// BST node structure (inline class)
class bstNode{
public: // public components in bstNode
// data members
bstType data;
bstNode* left;
bstNode* right;
// balancing information
int height;
// constructor
bstNode(bstType item){
left = NULL;
right = NULL;
data = item;
height = 0;
}
// destructor
// no special destructor is required for bstNode
};
// BST node pointer
typedef bstNode* bstNodePtr;
public: // public functions.....
¿Alguna idea sobre lo que puede estar causando esto? ¿Estoy sobrecargar la clase equivocada o la función mal? Cualquier ayuda se agradece - Me parece estar perderse ya que muchas cosas diferentes se están produciendo a la vez.
