c ++排序自定义函数

Question

I need to be able to pass in a variable by which to sort. I noticed that it only takes in the types that it will be sorting so I was wondering if it is possible to do something like that.

For example I need it to sort arrays each containing 3 integers by their 3rd int. How would you make a function like that if you did not know in advance what value you would be sorting by?

Answer 1

You said "For example I need it to sort arrays each containing 3 integers by their 3rd int," and that you won't know which index (which column) is significant until run time.

If you are able to use C++11, it can be this simple:

void mysort(vector<vector<int>>& v, int col)
{
    sort(v.begin(), v.end(),
         [col](const vector<int>& a, const vector<int>& b) -> bool
               { return a[col] < b[col]; });
}

If you are restricted to C++98, you can do the same thing, but instead of a lambda, you must write a functor that takes the column as a constructor parameter:

class ColumnSort {
    int col_;
public:
    ColumnSort(int col): col_(col) { }
    bool operator()(const vector& a, const vector& b) const {
        return a[col_] < b[col_];
    }
};

void mysort(vector< vector<int> >& v, int col)
{
    sort(v.begin(), v.end(), ColumnSort(col));
}

Finally, if you want a multi-column sort, the functor would look like this, where cols is an ordered list of columns to sort on:

class ColumnSort {
    vector<int> cols_;
public:
    ColumnSort(const vector<int>& cols): cols_(cols) { }
    bool operator()(const vector<int>& a, const vector<int>& b) const {
      for (int i = 0; i < cols_.size(); ++i) {
        if (a[cols_[i]] == b[cols_[i]]) continue;
        return a[cols_[i]] < b[cols_[i]];
      }
      return false;
    }
};

Answer 2

You can use a custom comparator constructed with the information about your custom sort order. You do it sort of like this.

// Normal sort, except the specified value always comes first
class LessThanWithPreferedValue {
    int n;
public:
    LessThanWithPreferedValue(int v) : n(v) {}

    boolean operator()( int a, int b ) const {
       if( a==n ) { return true ; }
       if( b==n ) { return false ; }
       return a<b;
    }
};

int main() {
  std::vector<int> v = { 2, 3, 4 , 6 ,8 };

  // Normal sort, but with 4 first
  std::sort(v.begin(), v.end(), LessThanWithPreferedValue(4) );
  // v = { 4, 2, 3, 6, 8}

  // Normal sort, but with 8 first
  std::sort(v.begin(), v.end(), LessThanWithPreferedValue(8) );
  // v = { 8, 2, 3, 4, 6}
}

Answer 3

Write a functor that takes arguments to determine how to sort. Here's a simple example that takes an argument to switch between ascending and descending order:

template<typename T>
class ReversibleComparator {
    bool asc;
public:
    ReversibleComparator(bool asc) : asc(asc) {}
    // This function performs the comparison,
    // returning true if a should come before b.
    bool operator()(const T& a, const T& b) {
        if(asc) return a < b;
        else return b < a;
    }
};

Of course, you could have as many parameters to the constructor as you want (or multiple constructors) and make the logic as complicated as you want, though it'll be called a lot, so making it really complicated would probably not be a good idea.

An example of calling it:

bool asc = true;
if(argc > 1 && argv[1] == string("-d"))
    asc = false;
std::sort(my_list.begin(), my_list.end(), ReversibleComparator(asc));

(Also, this example is a little contrived, since if what you want is to reverse the ordering, you can simply use rbegin() and rend() in place of begin() and end() respectively.)

Answer 4

Here I describe the C rtl qsort, but it is almost certainly almost the same as the c++ variant:

The sort function takes as a parameter a "comparison function". Each time the comparison function is called it is passed two parameters which are pointers to the two elements to compare.

After coercing the type of the parameters, you can then compare anything you want. For example, if the elements contain some struct with an integer array and you want to compare the nth items in them where the program's first parameter tells which column, something like this will work:

int which_index = (int) strtol (argv[1]);

int comparefunc (void *item1, void *item2)
{
     widget *w1, *w2;
     w1 = (widget *) item1;
     w2 = (widget *) item2;

     return w1->myarray[which_index] - w2->myarray[which_index];
}


widget table[1000];
qsort (table, n, sizeof table[0], comparefunc);