STL_算法_区间的比較(equal、mismatch、 lexicographical_compare)

C++ Primer 学习中。。

。

简单记录下我的学习过程 (代码为主)

//全部容器适用



equal(b,e,b2) //用来比較第一个容器[b,e)和第二个容器b2开头，是否相等

equal(b,e,b2,p)



mismatch(b,e,b2) //用来查找两个容器中第一个不相等的数据,返回迭代器

mismatch(b,e,b2,p)



lexicographical_compare(b,e,b2,e2) //用来比較第一个区间是否比第二个区间小

lexicographical_compare(b,e,b2,e2,p)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
using namespace std;

/*****************************************
//全部容器适用
equal(b,e,b2)       //用来比較第一个容器[b,e)和第二个容器b2开头。是否相等
equal(b,e,b2,p)
mismatch(b,e,b2)    //用来查找两个容器中第一个不相等的数据,返回迭代器
mismatch(b,e,b2,p)
lexicographical_compare(b,e,b2,e2)      //用来比較第一个区间是否比第二个区间小
lexicographical_compare(b,e,b2,e2,p)
*****************************************/

/*************************************************************************************
std::equal                     全部排序容器适用                           algorithm
--------------------------------------------------------------------------------------
template <class InputIterator1, class InputIterator2>
bool equal ( InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2 );

template <class InputIterator1, class InputIterator2, class BinaryPredicate>
bool equal ( InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, BinaryPredicate pred );

//eg：
template <class InputIterator1, class InputIterator2>
bool equal ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
{
while ( first1!=last1 )
{
if (!(*first1 == *first2))   // or: if (!pred(*first1,*first2)), for pred version
return false;
++first1; ++first2;
}
return true;
}
*************************************************************************************/

/*************************************************************************************
std::mismatch                   全部排序容器适用                           algorithm
--------------------------------------------------------------------------------------
template <class InputIterator1, class InputIterator2>
pair<InputIterator1, InputIterator2>
mismatch (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2 );

template <class InputIterator1, class InputIterator2, class BinaryPredicate>
pair<InputIterator1, InputIterator2>
mismatch (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, BinaryPredicate pred );

//eg：
template <class InputIterator1, class InputIterator2>
pair<InputIterator1, InputIterator2>
mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
{
while ( (first1!=last1) && (*first1==*first2) )  // or: pred(*first1,*first2), for the pred version
{ ++first1; ++first2; }
return make_pair(first1,first2);
}
*************************************************************************************/
/*************************************************************************************
std::lexicographical_compare               全部排序容器适用                 algorithm
--------------------------------------------------------------------------------------
template <class InputIterator1, class InputIterator2>
bool lexicographical_compare ( InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2 );

template <class InputIterator1, class InputIterator2, class Compare>
bool lexicographical_compare ( InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
Compare comp );
//eg：
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);
}
*************************************************************************************/

bool mypredicate (int i, int j)
{
return (i==j);
}

bool mycomp (char c1, char c2)
{
return tolower(c1)<tolower(c2);
}

int main()
{

//equal(b,e,b2)       //用来比較第一个容器[b,e)和第二个容器b2开头，是否相等
//equal(b,e,b2,p)

int myints[] = {20,40,60,80,100};          //   myints: 20 40 60 80 100
vector<int>myvector (myints,myints+5);     // myvector: 20 40 60 80 100

// using default comparison:
if (equal (myvector.begin(), myvector.end(), myints))
cout << "The contents of both sequences are equal." << endl;
else
cout << "The contents of both sequences differ." << endl;

myvector[3]=81;                            // myvector: 20 40 60 81 100

// using predicate comparison:
if (equal (myvector.begin(), myvector.end(), myints, mypredicate))
cout << "The contents of both sequences are equal." << endl;
else
cout << "The contents of both sequences differ." << endl;
cout<<endl;
/**-----------------------------------------------------------------------------
Output:
The contents of both sequences are equal.
The contents of both sequences differ.
-----------------------------------------------------------------------------**/

//mismatch(b,e,b2)    //用来查找两个容器中第一个不相等的数据,返回迭代器
//mismatch(b,e,b2,p)

list<int> mylist;
for (int i=1; i<6; i++) mylist.push_back (i*10);   // mylist: 10 20 30 40 50

int myints2[] = {10,20,80,40,1024};              // myints2: 10 20 80 40 1024

pair<list<int>::iterator,int*> mypair;

// using default comparison:
mypair = mismatch (mylist.begin(), mylist.end(), myints2);
cout << "First mismatching elements: " << *mypair.first;
cout << " and " << *mypair.second << endl;

mypair.first++;
mypair.second++;

// using predicate comparison:
mypair = mismatch (mypair.first, mylist.end(), mypair.second, mypredicate);
cout << "Second mismatching elements: " << *mypair.first;
cout << " and " << *mypair.second << endl;
cout <<endl;

/**-----------------------------------------------------------------------------
Output:
First mismatching elements: 30 and 80
Second mismatching elements: 50 and 1024
-----------------------------------------------------------------------------**/

//lexicographical_compare(b,e,b2,e2)      //用来比較第一个区间是否比第二个区间小  (长度和ASCII码)
//lexicographical_compare(b,e,b2,e2,p)

char first[]="apple";         // 5 letters
char second[]="apart";        // 5 letters   eg:apartment

cout << "Using default comparison (operator<): ";
if (lexicographical_compare(first,first+5,second,second+5))
cout << first << " is less than " << second << endl;
else if (lexicographical_compare(second,second+5,first,first+5))
cout << first << " is greater than " << second << endl;
else
cout << first << " and " << second << " are equivalent\n";

cout << "Using mycomp as comparison object: ";
if (lexicographical_compare(first,first+5,second,second+5,mycomp))
cout << first << " is less than " << second << endl;
else if (lexicographical_compare(second,second+5,first,first+5,mycomp))
cout << first << " is greater than " << second << endl;
else
cout << first << " and " << second << " are equivalent\n";
/**-----------------------------------------------------------------------------
Output:
Using default comparison (operator<): apple is greater than apart
Using mycomp as comparison object: apple is greater than apart
-----------------------------------------------------------------------------**/

return 0;
}