Ndtyjky

I have a vector called:

vector<MiniPair> miniPairVector;

MiniPair object has 2 property inside,1 is an integer docNumber other is a string word

I am trying to clear duplicates in this vector which means that if docNumber and word exist in another object inside vector remove the duplicates

This is what i have tried but it is producing an infinite loop:

for (int i = 0; i < miniPairVector.size(); i++) {



    for (int k = i + 1; k < miniPairVector.size(); k++) {



        if (miniPairVector[i].getDocNumber() == miniPairVector[k].getDocNumber() && miniPairVector[i].getWord() == miniPairVector[k].getWord()) {

            cout << "i am erasing" << endl;

            miniPairVector.erase(miniPairVector.begin() + k);



        }



    }



}

this is the minipair class:

#pragma once

// classes example

#ifndef MINIPAIR_H

#define MINIPAIR_H

#include <iostream>

using namespace std;



class MiniPair {

    friend bool operator<(MiniPair const &a, MiniPair const &b) {



        return a.docNumber < b.docNumber || a.docNumber == b.docNumber && a.word < b.word;

    }

    friend bool operator==(MiniPair const &a, MiniPair const &b) {



        return a.docNumber == b.docNumber && a.word == b.word;

    }

private:

    string word;

    int docNumber;



public:

    MiniPair();

    MiniPair(string word, int docNumber);

    string getWord();

    int getDocNumber();



};

#endif

My presumption is that you are doing this for a class.

First, while this may not be relevant for the problem you're solving write now because of class imposed constraints, this is a poor way of implementing this. When implemented correctly the number of comparisons will be something like miniPairVector.size() * miniPairVector.size(). That's a lot of comparisons, and way more than you actually need.

If I were trying to do this in a non-toy (or non-assignment) program, I would use the <algorithm> section of the standard library. I would use ::std::sort and then ::std::unique.

Here's how I would do it using those two:

#include <algorithm>



void remove_dupes(::std::vector<MiniPair> &minipair_vec)

{

    ::std::sort(minipair_vec.begin(), minipair_vec.end(),

                (MiniPair const &a, MiniPair const &b) -> bool {

                    return (a.getDocNumber() < b.getDocNumber())

                           || ((a.getDocNumber() == b.getDocNumber())

                               && (a.getWord() < b.getWord())));

               }); // End lambda and sort.

     auto newend = ::std::unique(minipair_vec.begin(), minipair_vec.end(),

                                (MiniPair const &a, MiniPair const &b) -> bool {

                                   return a.getDocNumber() == b.getDocNumber()

                                          && a.getWord() == b.getWord();

                                }); // End lambda and unique.

     minipair_vec.resize(newend - minipair_vec.begin());

}

I have tested it, so it should work just fine.

The general lesson is that if you find yourself looping, go through this set of questions:

• Am I indexing into a linear data structure? If so, why am I using indexes instead of iterators?


• Is there an algorithm that already does what I need, or can a couple of algorithms be easily composed to do what I need?

The code I presented should run in a time that's proportional to minipair_vec.size() * ::std::log2(minipair_vec.size()). The code you wrote would run in a time proportional to minipair_vec.size() * minipair_vec.size() (once you got it to work), which is a lot longer for a large list.

A C++98 solution:

#include <algorithm>

#include <string>

#include <vector>



struct MiniPair {

    int docNumber;

    std::string word;

    friend bool operator<(MiniPair const &a, MiniPair const &b) {

        return a.docNumber < b.docNumber || a.docNumber == b.docNumber && a.word < b.word;

    }

    friend bool operator==(MiniPair const &a, MiniPair const &b) {

        return a.docNumber == b.docNumber && a.word == b.word;

    }

};



int main() {

    std::vector<MiniPair> miniPairVector;

    // fill miniPairVector with data

    std::sort(miniPairVector.begin(), miniPairVector.end());

    miniPairVector.erase(std::unique(miniPairVector.begin(), miniPairVector.end()), miniPairVector.end());

}