Question

I’m trying to figure out the best way to sort an array under multiple criteria. I want to sort an array, then sort a subset of that array if they were equal under the first criteria.

Example:

Say we have the data: { ("cat", 2), ("dog", 4), ("cat", 1), ("dog", 3) }

We sort this first according to alphabetical order of the string:

{ ("cat", 2), ("cat", 1), ("dog", 4), ("dog", 3) }

Then we sort the two subsets (set of cats and the set of dogs) in increasing order of their numbers:

{ ("cat", 1), ("cat", 2), ("dog", 3), ("dog", 4) }

Also, I’m using a recursive quicksort method that has the following header:

void quickSort(vector<Type*>, int left, int right)

where left and right are the bounding indices by which the vector should be sorted.

Should I add code to the sorting method itself or should i call the sorting method again somehow?

Answer 1

Generally, you want a custom comparator to sort with.

struct Foo {
  std::string name;
  int count;
  struct Less {
    bool operator()(const Foo &lhs, const Foo &rhs) const {
      if ((int c = lhs.name.compare(rhs.name)) != 0)
        return c < 0;
      return lhs.count < rhs.count;
    }
  };
};

std::vector<Foo> foos;
// ...
std::sort(foos.begin(), foos.end(), Foo::Less());

If you can’t just use a single custom operator, you can use a stable sort.

As pointed out by Mark, std::sort is not a stable sort. Instead you would need to use std::stable_sort.

You want to sort them independently in order of increasing importance. So, you sort by numbers and then by the string.

struct Foo {
  std::string name;
  int count;
  struct NameLess {
    bool operator()(const Foo &lhs, const Foo &rhs) const {
      return lhs.name.compare(rhs.name) < 0;
    }
  };
  struct CountLess {
    bool operator()(const Foo &lhs, const Foo &rhs) const {
      return lhs.count < rhs.count;
    }
  };
};

std::vector<Foo> foos;
// ...
std::stable_sort(foos.begin(), foos.end(), Foo::CountLess());
std::stable_sort(foos.begin(), foos.end(), Foo::NameLess());

You would prefer the first obviously, but the latter can come in handy for keeping combinatorial and/or run-time configurable algorithms simplistic.

For reference:

cplusplus.com C++ : Reference : STL Algorithms : stable_sort

cplusplus.com C++ : Reference : STL Algorithms : sort