Custom is_sorted function template - c++

Question

I want to write my own is_sorted function template implementation instead of using std::is_sorted. Could you give me any idea about how to do it?
I want to use it only for arrays. So I want to make declaration like this:
template <typename T, size_t N>
bool is_sorted (const T (&array)[N]); and
bool operator>(const A &, const A &); is declared.

Answer 1

The obvious way would be to compare each item to the one after it, and see if it's <= to that one.
You probably don't want to do that directly though. First of all, for sorting, the client is typically only required to ensure that a < b is defined, so you want to use < instead of <=. Second, you want to allow (but not require) the user to pass a comparator of their own, in case < isn't defined directly for some type or the desired sort uses a different criteria than < defines.
As such, you probably want to define two versions of is_sorted, one using < directly, the other using a comparator passed by the user.
#include <iterator>
#include <functional>
template <class InIt>
bool is_sorted(InIt b, InIt e) {
if (b == e) // No items -- sorted by definition
return true;
typename std::iterator_traits<InIt>::value_type first = *b;
++b;
while (b != e) { // skip if e-b == 1 (single item is sorted)
if (*b < first)
return false;
first = *b;
++b;
}
return true;
}
template <class InIt, class Cmp>
bool is_sorted(InIt b, InIt e, Cmp cmp) {
if (b == e)
return true;
typename std::iterator_traits<InIt>::value_type first = *b;
++b;
while (b != e) { // skip if e-b == 1 (single item is sorte)
if (cmp(*b, first))
return false;
first = *b;
++b;
}
return true;
}
To keep myself honest, a bit of test code, with sorted, unsorted, identical, and reversed elements, using std::vector, std::deque, std::array, and a built-in array:
#ifdef TEST
#include <array>
#include <vector>
#include <iostream>
#include <deque>
int main() {
std::vector<int> sorted{1, 2, 3, 4, 6, 100};
std::deque<int> unsorted{1, 5, 2, 7, 4};
std::array<int, 7> ident = {1, 1, 1, 1, 1, 3, 3};
int rev[] = {5, 4, 3, 2, 1};
if (!is_sorted(std::begin(sorted), std::end(sorted)))
std::cout << "Sorted array detected as un-sorted\n";
if (is_sorted(std::begin(unsorted), std::end(unsorted)))
std::cout << "Un-sorted array detected as sorted\n";
if (!is_sorted(std::begin(ident), std::end(ident)))
std::cout << "sorted array with duplicated detected as un-sorted\n";
if (!is_sorted(std::begin(rev), std::end(rev), std::greater<int>()))
std::cout << "Reverse sorted array detected as un-sorted\n";
return 0;
}
#endif
This works fine for me with gcc 4.7.2. The is_sorted code seems to work fine with VC++ 2012 as well (though the test code requires some minor modifications, e.g., to eliminate use of uniform initialization, which it doesn't support yet).
Edit: if you don't mind a slightly tighter requirement on the iterators (forward iterators instead of input iterators), you can make the code simpler and often more efficient. For example, the code can be reduced to something like this:
template <class FwdIt>
bool is_sorted(FwdIt b, FwdIt e) {
if (b == e) // No items -- sorted by definition
return true;
for (FwdIt first = b; ++b != e; first = b)
if (*b < *first)
return false;
return true;
}

Answer 2

Make sure each element in the container is <= the next element.
If you only have a < comparator (like most STL algorithms), make sure there are no elements in the container where the given element is < the previous element.