алгоритм обратного индекса для дерева AVL дублирует ключ каждый раз с ++

Question

Я создал инвертированный алгоритм индексации для хранения индексов в дереве AVL, но каждый раз, когда я вызываю функцию, она заполняет дерево новым ключом и ключами, которые уже находятся в дереве.

здесь function

void IdeaBank::AVLTreeIndexing(){
    for (int loop = 0; loop < newIdea.size(); loop++) {
        vector<string> keywords = newIdea[loop].getKeyword();
        for (int i = 0; i < keywords.size(); i++) {
            Index input;
            input.key = keywords[i]; 
            for (int j = 0; j < newIdea.size(); j++) {
                if (newIdea[j].foundWordInBoth(keywords[i])) {
                    input.idList.push_back(newIdea[j].getID());
                    //removeDuplicates(input.idList);

                }
            } 
            tree.AVL_Insert(input);
        }
    }
}

приведенный выше код ищет в моем банке идей совпадения и возвращает идентификатор идеи с совпадением, которое будет сохранено в моем дереве avl. Я вызываю эту функцию каждый раз, когда создаю новую идею, однако она хранит новый ключ, а также все предыдущие ключи.

Это то, что я пытался сделать: перед вставкой в ​​дерево AVL у меня есть функция, чтобы удалить дубликаты из моего вектора, а затем вставить в мое дерево. однако это не решило проблему.

вот моя функция для удаления дубликатов

void removeDuplicates(vector<int> &v){
            auto end = v.end();
            for (auto it = v.begin();it !=end;it++){
                end = remove(it+1,end,*it);
            }
            v.erase(end,v.end());
        }

код был скопирован из другого вопроса переполнения стека, который был помечен как правильный.

Я ищу способ проверить, существует ли ключ в дереве и игнорирует ли его вместо повторного заполнения дерева дубликатами.

РЕДАКТИРОВАТЬ: ниже приведен мой код для моих функций вставки. Я думал, что может быть вместо этого есть способ удалить дубликаты?

template <class TYPE>
struct NODE 
    {
     TYPE    data;
     NODE   *left;
     NODE   *right;
     int     bal;
     int     count;
    } ; // NODE

template <class TYPE, class KTYPE>
bool   AvlTree<TYPE, KTYPE> :: AVL_Insert (TYPE dataIn) 
{
//  Local Definitions 
    NODE<TYPE>  *newPtr;
    bool         taller;

//  Statements 
    if (!(newPtr = new NODE<TYPE>))
       return false;
    newPtr->bal    = EH;
    newPtr->right  = NULL;
    newPtr->left   = NULL;
    newPtr->data   = dataIn;

    tree = _insert(tree, newPtr, taller);
    count++;
    return true;
}   //  Avl_Insert   

/*  ======================= _insert =======================
    This function uses recursion to insert the new data into 
    a leaf node in the AVL tree.
       Pre    application has called AVL_Insert, which passes 
              root and data pointers
       Post   data have been inserted
       Return pointer to [potentially] new root
*/

template <class TYPE, class KTYPE>
NODE<TYPE>*  AvlTree<TYPE,  KTYPE> 
         ::  _insert (NODE<TYPE>  *root, 
                      NODE<TYPE>  *newPtr, 
                      bool&        taller)
{
//  Statements   
    if (!root)
    {
        root    = newPtr;
        taller  = true;
        return  root;
    } //  if NULL tree 

    {
        return newPtr->data;
    }

    if (newPtr->data.key < root->data.key)
       {
        root->left = _insert(root->left, 
                             newPtr, 
                             taller);
        if (taller)
           //  Left subtree is taller 
           switch (root->bal)
              {
               case LH: // Was left high--rotate 
                        root = leftBalance (root, taller);
                        break;

               case EH: // Was balanced--now LH 
                        root->bal = LH;
                        break;

               case RH: // Was right high--now EH 
                        root->bal = EH;
                        taller    = false;
                        break;
              } // switch 
       } //  new < node 
    else 
       //  new data >= root data 
       {
        root->right = _insert (root->right, 
                               newPtr, 
                               taller);
        if (taller)
           // Right subtree is taller
           switch (root->bal)
               {
                case LH: // Was left high--now EH 
                         root->bal = EH;
                         taller    = false;
                         break;

                case EH: // Was balanced--now RH
                         root->bal = RH;
                         break;

                case RH: // Was right high--rotate 
                         root = rightBalance (root, taller);
                         break;
               } //  switch 
       } //  else new data >= root data 
    return root;
}   //  _insert