二叉搜索树

我现在正在做一个学校的项目。任务是在给定相应的头文件的情况下编写模板化二叉搜索树的实现。

我的问题是，因为它是模板化的，我不确定如何在插入或查找数据项之间进行比较。

头文件:

template < typename DataType, class KeyType >    // DataType : tree data item
class BSTree                                     // KeyType : key field
{
  public:
// Constructor
BSTree ();                         // Default constructor
BSTree ( const BSTree<DataType,KeyType>& other );   // Copy constructor
BSTree& operator= ( const BSTree<DataType,KeyType>& other );
                      // Overloaded assignment operator
// Destructor
~BSTree ();
// Binary search tree manipulation operations
void insert ( const DataType& newDataItem );  // Insert data item
bool retrieve ( const KeyType& searchKey, DataType& searchDataItem ) const;
                                              // Retrieve data item
bool remove ( const KeyType& deleteKey );            // Remove data item
void writeKeys () const;                      // Output keys
void clear ();                                // Clear tree
// Binary search tree status operations
bool isEmpty () const;                        // Tree is empty
// !! isFull() has been retired. Not very useful in a linked structure.
// Output the tree structure -- used in testing/debugging
void showStructure () const;
// In-lab operations
int getHeight () const;                       // Height of tree
int getCount () const;            // Number of nodes in tree
void writeLessThan ( const KeyType& searchKey ) const; // Output keys < searchKey
protected:
class BSTreeNode                  // Inner class: facilitator for the BSTree class
{
  public:
    // Constructor
    BSTreeNode ( const DataType &nodeDataItem, BSTreeNode *leftPtr, BSTreeNode *rightPtr );
    // Data members
    DataType dataItem;         // Binary search tree data item
    BSTreeNode *left,    // Pointer to the left child
               *right;   // Pointer to the right child
};
// Recursive helpers for the public member functions -- insert
// prototypes of these functions here.
void showHelper      ( BSTreeNode *p, int level ) const;

// Data member
BSTreeNode *root;   // Pointer to the root node
};

讨论的函数是insert()。

我有以下代码:

template <typename DataType, class KeyType>
void BSTree< DataType,  KeyType>::insert(const DataType& newDataItem)
{
if(isEmpty())
    {
        root = new BSTreeNode(newDataItem, NULL, NULL);
    }
else
    {
        BSTreeNode *ptr = root;
        while(ptr != NULL)
            {
                if((*ptr)>dataItem > newDataItem)
                    {
                        ptr = ptr->left;
                    }
                else if((*ptr).dataItem < newDataItem)
                    {
                        ptr = ptr->right;
                    }
            }
        ptr = new BSTreeNode(newDataItem, NULL, NULL);
    }
}

，我收到以下错误:

44 E:School302Labs7BSTree.cpp no match for 'operator>' in 'ptr->BSTree<TestData, int>::BSTreeNode::dataItem > newDataItem' 
49 E:School302Labs7BSTree.cpp no match for 'operator<' in 'ptr->BSTree<TestData, int>::BSTreeNode::dataItem < newDataItem' 

我该如何处理?是否需要编写重载操作符，如果需要，如何开始?

在这里调用insert:

class TestData
{
  public:
void setKey ( int newKey )
    { keyField = newKey; }   // Set the key
int getKey () const
    { return keyField; }     // Returns the key
  private:
int keyField;                // Key for the data item
};
int main()
{
BSTree<TestData,int> testTree;   // Test binary search tree
TestData testData;               // Binary search tree data item
int inputKey;                    // User input key
char cmd;                        // Input command
print_help();
do
{
    testTree.showStructure();                     // Output tree
    cout << endl << "Command: ";                  // Read command
    cin >> cmd;
    if ( cmd == '+'  ||  cmd == '?'  ||
         cmd == '-'  ||  cmd == '<'     )
       cin >> inputKey;
    switch ( cmd )
    {
      case 'P' : case 'p' :
           print_help();
           break; 
      case '+' :                                  // insert
           testData.setKey(inputKey);
           cout << "Insert : key = " << testData.getKey()
                << endl;
           testTree.insert(testData);
           break;
}

我没有包括开关的其余部分，因为它在示例中不需要。

我假设这个问题是因为我正在比较两种不同的数据类型或尝试。我该怎么解决这个问题?

我用下面的代码解决了我的问题:

template <typename DataType, class KeyType>
void BSTree< DataType,  KeyType>::insert(const DataType& newDataItem)
{
BSTreeNode* temp = new BSTreeNode(newDataItem, NULL, NULL);
if(isEmpty())
    {
        root = temp;
    }
else
    {
        BSTreeNode* ptr = root;
        while(ptr != NULL)
            {
                if(ptr > temp)
                    {
                        ptr = ptr->left;
                    }
                else
                    {
                        ptr = ptr->right;
                    }
            }
        ptr = temp;
    }
}

和

template <typename DataType, class KeyType>
bool BSTree<DataType, KeyType>::BSTreeNode::operator>(const BSTreeNode*& other)
{
if((*other).dataItem < (*this).dataItem)
    {
        return true;
    }
return false;
}