3种向量的高效排序算法

Question

I have 3 vectors, category description and price I have written this piece of code to put the vectors organised by category into a file called menuFile :

for(int x = 0; x < _category.size(); x++){
    if(_category[x].compare("Starter") == 0){
        menuFile << _category[x] << ":" << _description[x] << ":" << _price[x] << endl;
    }
}

for(int x = 0; x < _category.size(); x++){
    if(_category[x].compare("Main") == 0){
        menuFile << _category[x] << ":" << _description[x] << ":" << _price[x] << endl;
    }
}

for(int x = 0; x < _category.size(); x++){
    if(_category[x].compare("Pudding") == 0){
        menuFile << _category[x] << ":" << _description[x] << ":" << _price[x] << endl;
    }
}

for(int x = 0; x < _category.size(); x++){
    if(_category[x].compare("Drink") == 0){
        menuFile << _category[x] << ":" << _description[x] << ":" << _price[x] << endl;
    }
}      

But this does not seem like a very efficient method. Is the a better way to do this?

Answer 1

I believe you should create a struct to handle the three types of data and then make a vector for it.

for example:

struct Menu {
    string category;
    string description;
    int price;
};

then i would recommend you to implement a comparator to decide on how to sort the data. Let's say sort by the price (You can decide on how to implement the overloaded operator of course).

struct Menu {
    string category;
    string description;
    int price;
    bool operator < (const Menu& rhs) const {
        return (this->price < rhs.price);
    }
};

then just make a vector for this struct and sort it.

vector<Menu> menu;
// do something, insert data
sort(menu.begin(),menu.end());

Then output accordingly.

for(int x = 0; x < menu.size(); x++){
    menuFile << menu[x].category << ":" << menu[x].description << ":" << menu[x].price << endl;
}  

Answer 2

I don't know what your container types are, so I'm going to assume std::string . The simplest thing might be to just make a separate vector of tuple s:

using StrTuple = std::tuple<std::string*, std::string*, std::string*>;
std::vector<StrTuple> combined;
for (size_t i = 0; i < _category.size(); ++i) {
    combined.emplace_back(&_category[i], &_description[i], &_price[i]);
}

And then sort that one by category:

std::sort(std::begin(combined), std::end(combined),
          [](const StrTuple& lhs, const StruTuple& rhs) {
              return *std::get<0>(lhs) < *std::get<0>(rhs);
          });

And then just stream it in order:

for (auto& t : combined) {
    menuFile << *std::get<0>(t) << ":" << *std::get<1>(t) << ":" << *std::get<2>(t) << std::endl;
}

The same could be achieved with a separate type instead, something like:

struct CombinedValues {
    std::string *category, *description, *price;
};

Answer 3

I do not think there is a much more efficient algorithm to do that. You may think so because you do 4 loop with the same thing. But you are still doing O(n) efficiency. Adding a sort operation like some proposition above would add a step running at O(n*log(n)) efficiency, which is way worse.

You still need the 4 loops, so the only thing we can try to optimize is the testing, that is replacing the string compare() operation in each loop by something faster. Something possible would be to replace the string test by an integer test, meaning pre-computing a category number in a new vector (ie a value 0 if category=="Starter", 1 if "Main", etc and a value different from 0..3 if not any of the interesting category (if that is possible)

That would mean an initial loop to compute this category, which can be made more efficient (using an average of 2 string comparison). Or even less using a hash map of the category string.

So in the loops, we just do an integer comparison instead of a string comparison for each element. However, we add the time to compute the category number in the first loop. It is not obvious at first glance which will be faster: 4 loops and 4*n string comparisons or 4 loops, 2*n string comparisons and 4*n integer comparisons. That may be faster, if comparing strings are much more costly than comparing integers.

For this kind of stuff, only way to know is to measure actual execution time. Obviously, all this is time consuming, so only to be done if this is really necessary (ie your profiler tells you that this part needs to be optimized)