C++（lexicographical_compare；next_permutation；prev_permutation）

一、lexicographical_compare

头文件algorithm

default (1)	
template <class InputIterator1, class InputIterator2>
  bool lexicographical_compare (InputIterator1 first1, InputIterator1 last1,
                                InputIterator2 first2, InputIterator2 last2);
custom (2)	
template <class InputIterator1, class InputIterator2, class Compare>
  bool lexicographical_compare (InputIterator1 first1, InputIterator1 last1,
                                InputIterator2 first2, InputIterator2 last2,
                                Compare comp);

字典小于比较

如果范围[first1，last1]按字典顺序比较范围[first2，last2]，则返回true。

字典比较是一种比较，通常用于在字典中按字母顺序对单词进行排序; 它涉及顺序地比较两个范围中具有相同位置的元素彼此之间的比较，直到一个元素不等同于另一个元素。 比较这些第一非匹配元素的结果是词典比较的结果。

如果两个序列比较相等直到其中一个结束，则较短的序列按字典顺序小于较长的序列。

使用operator <作为第一个版本比较元素，comp作为第二个版本。 如果（！（a <b）&&！（b <a））或if（！comp（a，b）&&！comp（b，a）），则认为两个元素a和b是等价的。

此函数模板的行为等效于：

template <class InputIterator1, class InputIterator2>
  bool lexicographical_compare (InputIterator1 first1, InputIterator1 last1,
                                InputIterator2 first2, InputIterator2 last2)
{
  while (first1!=last1)
  {
    if (first2==last2 || *first2<*first1) return false;
    else if (*first1<*first2) return true;
    ++first1; ++first2;
  }
  return (first2!=last2);
}

参数

1. first1，last1
   将迭代器输入到第一个序列的初始和最终位置。 使用的范围是[first1，last1]，它包含first1和last1之间的所有元素，包括first1指向的元素，但不包括last1指向的元素。
2. first2，last2
   将迭代器输入到第二个序列的初始和最终位置。 使用的范围是[first2，last2）。
3. comp
   二进制函数，接受迭代器指向的两个类型的参数，并返回一个可转换为bool的值。 返回的值指示第一个参数是否在其定义的特定严格弱顺序中被认为是在第二个参数之前。
   该函数不得修改其任何参数。这可以是函数指针或函数对象。

返回值

如果第一个范围按字典顺序比较小于第二个范围，则为true。否则为false（包括两个范围的所有元素相同时）。

// lexicographical_compare example
#include <iostream>     // std::cout, std::boolalpha
#include <algorithm>    // std::lexicographical_compare
#include <cctype>       // std::tolower

// a case-insensitive comparison function:
bool mycomp (char c1, char c2)
{ return std::tolower(c1)<std::tolower(c2); }

int main () {
  char foo[]="Apple";
  char bar[]="apartment";

  std::cout << std::boolalpha;

  std::cout << "Comparing foo and bar lexicographically (foo<bar):\n";

  std::cout << "Using default comparison (operator<): ";
  std::cout << std::lexicographical_compare(foo,foo+5,bar,bar+9);
  std::cout << '\n';

  std::cout << "Using mycomp as comparison object: ";
  std::cout << std::lexicographical_compare(foo,foo+5,bar,bar+9,mycomp);
  std::cout << '\n';

  return 0;
}

默认比较比较纯ASCII字符代码，其中’A’（65）比小于’a’（97）。
我们的mycomp函数在比较它们之前将字母转换为小写，所以这里不匹配的第一个字母是第三个字母（‘a’与’p’）。

二、next_permutation

头文件algorithm

default (1)	
template <class BidirectionalIterator>
  bool next_permutation (BidirectionalIterator first,
                         BidirectionalIterator last);
custom (2)	
template <class BidirectionalIterator, class Compare>
  bool next_permutation (BidirectionalIterator first,
                         BidirectionalIterator last, Compare comp);

将范围转换为下一个排列

将[first，last]范围内的元素重新排列为下一个按字典顺序排列的更大排列。

排列是N中的每一个！元素可以采取的可能安排（其中N是范围内元素的数量）。可以根据他们如何比较词典相互比较来排序不同的排列;第一个这样排序的可能排列（将字典比较小于所有其他排列的那个排列）是使其所有元素按升序排序的排序，并且最大排列的所有元素按降序排序。

各个元素的比较使用operator <用于第一个版本，或comp用于第二个版本。

如果函数可以确定下一个更高的排列，它会重新排列元素并返回true。如果那是不可能的（因为它已经处于最大可能的排列），它会根据第一个排列重新排列元素（按升序排序）并返回false。
参数
第一，最后
双向迭代器到序列的初始和最终位置。 使用的范围是[first，last），它包含first和last之间的所有元素，包括first指向的元素，但不包括last指向的元素。
BidirectionalIterator应指向正确定义交换的类型。
补偿
二进制函数，接受BidirectionalIterator指向的类型的两个参数，并返回一个可转换为bool的值。 返回的值指示第一个参数是否在其定义的特定严格弱顺序中被认为是在第二个参数之前。
该函数不得修改其任何参数。
这可以是函数指针或函数对象。

返回值
如果函数可以将对象重新排列为字典顺序更大的排列，则为true。
否则，该函数返回false以指示排列不大于前一个，但最低可能（按升序排序）。

// next_permutation example
#include <iostream>     // std::cout
#include <algorithm>    // std::next_permutation, std::sort

int main () {
  int myints[] = {1,2,3};

  std::sort (myints,myints+3);

  std::cout << "The 3! possible permutations with 3 elements:\n";
  do {
    std::cout << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n';
  } while ( std::next_permutation(myints,myints+3) );

  std::cout << "After loop: " << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n';

  return 0;
}

三、prev_permutation

头文件algorithm

default (1)	
template <class BidirectionalIterator>
  bool prev_permutation (BidirectionalIterator first,
                         BidirectionalIterator last );
custom (2)	
template <class BidirectionalIterator, class Compare>
  bool prev_permutation (BidirectionalIterator first,
                         BidirectionalIterator last, Compare comp);

将范围转换为先前的排列

将[first，last]范围内的元素重新排列为上一个按字典顺序排列的排列。

排列是N中的每一个！元素可以采取的可能安排（其中N是范围内元素的数量）。可以根据他们如何比较词典相互比较来排序不同的排列;第一个这样排序的可能排列（将字典比较小于所有其他排列的那个排列）是使其所有元素按升序排序的排序，并且最大排列的所有元素按降序排序。

各个元素的比较使用operator <用于第一个版本，或comp用于第二个版本。

如果函数可以确定先前的排列，则它会重新排列元素并返回true。如果那是不可能的（因为它已经处于最低可能的排列），它会根据最后的排列重新排列元素（按降序排序）并返回false。

参数

1. first，last
   双向迭代器到序列的初始和最终位置。 使用的范围是[first，last），它包含first和last之间的所有元素，包括first指向的元素，但不包括last指向的元素。
   BidirectionalIterator应指向正确定义交换的类型。
2. comp
   二进制函数，接受BidirectionalIterator指向的类型的两个参数，并返回一个可转换为bool的值。 返回的值指示第一个参数是否在其定义的特定严格弱顺序中被认为是在第二个参数之前。
   该函数不得修改其任何参数。这可以是函数指针或函数对象。

返回值

如果函数可以将对象重新排列为lexicographicaly较小的排列，则为true。否则，该函数返回false以指示排列不小于前一个，但最大可能（按降序排序）。

// prev_permutation example
#include <iostream>     // std::cout
#include <algorithm>    // std::next_permutation, std::sort, std::reverse

int main () {
  int myints[] = {1,2,3};

  std::sort (myints,myints+3);
  std::reverse (myints,myints+3);

  std::cout << "The 3! possible permutations with 3 elements:\n";
  do {
    std::cout << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n';
  } while ( std::prev_permutation(myints,myints+3) );

  std::cout << "After loop: " << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n';

  return 0;
}