STL-算法

	6.算法
（1）算法介绍
（1）什么是算法
	所谓算法就是数据的具体处理方式，在程序中算法的常见组织形式就是
	函数，单个的子函数就是一个小型的算法单元。


（2）c++中涉及的算法有两类
 	（1）c++函数库提供的算法函数（现成可用的算法）

		（1）成员算法函数
			所有的容器的都有自己的成员算法函数，比如vector/list/map都提供了
			swap算法函数。

			除此外C++中所有类库提供的类，比如string/array都有成员算法。

			成员算法的特点是，成员算法的操作几乎只与当前类有关。

		（2）全局算法
			c++中实现了大量的全局算法，这些全局算法的特点就是，可以针对很多
			类型的数据操作，几乎都是利用函数模板实现，具有高度的抽象性，与具
			体的数据类型无关。
	
			c++的STL模板库就提供了专门针对容器的全局算法函数。

	（2）自定义算法
		（1）c++编程的工作是什么
			编写各种算法函数，定义类只是实现各种成员算法的封装的一种手段，整个
			c++程序真正核心是各种算法函数。
	

		（2）全局算法和成员算法
			（1）与类相关的就写为成员算法函数
			（2）超脱各种类类型的，就写成全局算法，这一点在讲函数时就已经提到过。


（3）操作STL容器时涉及的算法
	（1）使用容器成员算法
	（2）STL全局算法
	（3）自定义自己的针对这些容器操作的算法函数（成员/全局）
	
		也就是说我们可以通过容器提供的迭代器遍历，自己实现对容器的增加/删除/查找/
		修改/排序等算法，但不提倡这样的做法。

	注意：如果使用STL提供的外部算法函数的话，必须包含<algorithm>头文件。


（2）STL全局算法大致有三类

（1）查找类
	find()，find_end()，adjacent_find()，count(), mismatch(),

	seaech(), equal()。
（2）修改类
	swap(), copy(), transform(). replace(), remove(), reverse(),
	rotate(), fill(), random_shffle()。

（3）排序类
	sort() stable_sort(), binary_search(), merage(), min(), 
	max()。		
	

（3）查找类算法
   （1）常用全局算法函数

find()：只有一个函数模板
	函数模板：
	template <class InputIterator, class T>
	InputIterator find ( InputIterator first, InputIterator last, const T& value );
	
	功能：查找[first,last)之间是否有value，没有就返回end()。
	
find_if()：只有一个模板
	template <class InputIterator, class Predicate>
	InputIterator find_if ( InputIterator first, InputIterator last, Predicate pred );
	功能：根据自定义函数进行比较查找。由于该函数默认只允许一个参数。
		为了让比较更为灵活，往往需要定义函数类类型（或者利用仿函数和绑定实现也可以，
		具体请看例子）。
	
find_end()：提供两个函数模板
	template <class ForwardIterator1, class ForwardIterator2>
		ForwardIterator1 find_end ( ForwardIterator1 first1, ForwardIterator1 last1,
                           ForwardIterator2 first2, ForwardIterator2 last2 );
	功能：在[ForwardIterator1,ForwardIterator2)查找[first2, last2)中
		任何一个元素出现的最后位置，返回指向该位置的迭代器。


	template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
		ForwardIterator1 find_end ( ForwardIterator1 first1, ForwardIterator1 last1,
                           ForwardIterator2 first2, ForwardIterator2 last2.
                           BinaryPredicate pred);
	功能：在[ForwardIterator1,ForwardIterator2)查找[first2, last2)，但是
		多了一个参数，可以用于传递一个比较函数的地址。

find_first_of：功能与模板和find_end相似，只是返回的是第一次出现的位置的
	迭代器。

	
adjacent_find()：有两个模板
	template <class ForwardIterator>
		ForwardIterator adjacent_find ( ForwardIterator first, ForwardIterator last );
	功能：查询相邻两个元素是否相等，如果相等就返回指向第一个元素的
		迭代器。	
		
	template <class ForwardIterator, class BinaryPredicate>
		ForwardIterator adjacent_find ( ForwardIterator first, ForwardIterator last,
                              BynaryPredicate pred );
	功能：查询相邻两个元素是否相等，如果相等就返回指向第一个元素的
		迭代器，可以提供自己定义的比较函数。

count()：只有一个函数模板
	template <class InputIterator, class T>
		typename iterator_traits<InputIterator>::difference_type
			count ( ForwardIterator first, ForwardIterator last, const T& value );
	功能：在[ForwardIterator1,ForwardIterator2)查找value的出现的次数并返回。	
	
   （2）例子：			
	#include <iostream>
	#include <algorithm>
	#include<iterator>
	#include<list>

using namespace std;
class Student {
public:
    	Student(const string name=" ", const string num=" "):name(name), num(num) { }

   	 	string getname() const { return name; }
    	string getnum() const { return num; }
private:
    	string name;
    	string num;
};
class Compare {
public:
    	Compare(const Student *stu, int comptype):stu(stu), comptype(comptype) {  }
    	bool operator()(Student *op) {
            	if(1 == comptype) {
                    	return(op->getname()==stu->getname());
           		} else if(2 == comptype) {
                    	return(op->getnum()==stu->getnum());
            	}
    	}
private:
    	const Student *stu;
    	int comptype;
};
bool compare(Student *&op) {
    	return (op->getname() == "name1");
}

bool compare1(Student *&op1, Student *&op2) {
    	return (op1->getname() == op2->getname());
}

bool compare2(Student *&op1, Student *&op2) {
    	if(op1 == op2) return true;
    	else if(op1->getname() == op2->getname()&&op1->getnum() == op2->getnum()) {
            	return true;
    	} else return false;
}
void print_find_element(std::list<Student *>::iterator it, std::list<Student *>::iterator end) {
    	if(it != end) {
            	cout <<"查找结果：" <<(*it)->getname()<<"   "<<(*it)->getnum()<<endl;
    	} else cout<<"没有找到"<<endl;
}

int main(void)
{
    	Student *stu[10] = {NULL};
    	std::list<Student *>::iterator it;//定义一个空的list，存放的数据类型伟Student *

    	/* 初始化对象数组 */
    	for(int i=0; i<sizeof(stu)/sizeof(stu[0]); i++) {
            	stu[i] = new Student(string("name")+string(1, i+'0'), string("11")+string(1, i+'0'));
    	}
    	/* 利用对象数组初始化list */
    	std::list<Student *> v1(stu, stu+sizeof(stu)/sizeof(stu[0]));

    	cout<<"使用find查找，由于容器存放的是对象地址，所以需要为对象地址查找 "<<endl;
    	it = find(v1.begin(), v1.end(), stu[1]);
    	print_find_element(it, v1.end());

    	cout<<"\n使用find_if查找，自定义比较函数，在函数中确定查找方式为按名字查找 "<<endl;
    	it = find_if(v1.begin(), v1.end(), compare);
    	print_find_element(it, v1.end());

    	cout<<"\n使用find_if查找，定义比较函数类类型，重写()后按照学号查找 "<<endl;
    	it = find_if(v1.begin(), v1.end(), Compare(new Student("wwwww", "111"), 2));
    	print_find_element(it, v1.end());

    	cout<<"\n使用find_first_of查找[stu+2, stu+5)中某个在list中出现的最开始的位置，自定义比较函数"<<endl;
    	it = find_first_of(v1.begin(), v1.end(), stu+2, stu+5,compare1);
    	print_find_element(it, v1.end());

    	cout<<"\n使用adjacent_find在list中使用自定义比较函数查找否有相等的相邻元素"<<endl;
    	it = adjacent_find(v1.begin(), v1.end(), compare2);
    	print_find_element(it, v1.end());
	
    	return 0;
}


（4）修改类算法
  （1）常见函数
swap()：只有一个函数模板
	template <class T> void swap ( T& a, T& b );
	功能：交换两个a和b两个容器中的内容。
	
copy()：只有一个模板
	template <class InputIterator, class OutputIterator>
	 OutputIterator copy ( InputIterator first, InputIterator last, OutputIterator result );
	功能：将[InputIterator, OutputIterator)内容复制到result开始的位置。		
		但是被复制的容器不能为空，比如使用vector和list为空时，必须
		是使用resize函数预先开辟元素空间，如果开辟的空间不够只能复制
		一部分，如果空间过多，会导致无效内容的存在。

	使用copy函数只能实现浅拷贝，如果容器存放的是指针，那么经过copy复制后，
	两个容器里面存放的所有指针指向的都是相同的数据空间。


transform()：有两个模板，实现对容器中数据进行指定操作。

	前面提到，copy只能浅拷贝，如果希望实现深拷贝，我们就需要使用transform
	函数。之所以能够实现深拷贝，是因为我们可以通过指定自定义的函数实现具体
	的拷贝过程。

	对transform来说，同样要求被复制的容器不能为空，比如vector和list，必须
	是使用resize函数开辟元素空间，如果开辟的空间不够只能复制一部分，如果空
	间过多，会导致无效内容存在。

	template < class InputIterator, class OutputIterator, class UnaryOperator >
		OutputIterator transform ( InputIterator first1, InputIterator last1,
                         OutputIterator result, UnaryOperator op);
	功能：对[first1, last1)之间内容做指定的op操作，将结果转存到result容器中，
		

	template < class InputIterator1, class InputIterator2,
       		class OutputIterator, class BinaryOperator >
		OutputIterator transform ( InputIterator1 first1, InputIterator1 last1,
                         InputIterator2 first2, OutputIterator result,
                         BinaryOperator binary_op );
	功能：对[first1, first1)和first2开时的内容进行指定的op运算，结果转存到	
		result中，要求用于做运算的两个容器内容要想等，否者会抛出异常。
	

replace()：只有一个模板
	template < class ForwardIterator, class T >
		void replace ( ForwardIterator first, ForwardIterator last,
             		const T& old_value, const T& new_value );
	功能：将[first, last)之间old_value替换为new_value。


remove()：只有一个模板
	template < class ForwardIterator, class T >
		ForwardIterator remove ( ForwardIterator first, ForwardIterator last,
                       const T& value );
	功能：将[first, last)之间等于value的数据删除。
	
	
remove_if()：只有一个模板
	template < class ForwardIterator, class Predicate >
	 ForwardIterator remove_if ( ForwardIterator first, ForwardIterator last,
                          Predicate pred );
	功能：同remove，但是可以按照自定义的pred的要求删除。
		

reverse()：只有一个模板
	template <class BidirectionalIterator>
	void reverse ( BidirectionalIterator first, BidirectionalIterator last);
	功能：将[first, last)之间元素顺序颠倒。


rotate()：只有一个模板
	template <class ForwardIterator>
	void rotate ( ForwardIterator first, ForwardIterator middle,
            ForwardIterator last );
	功能：将[middle,last)元素旋转到开始位置，middle为第一个元素，将
		[first,middle)元素旋转到后面。
		比如123456789，以4为middle进行旋转后为456789123。

fill()：只有一个模板
	template < class ForwardIterator, class T >
	void fill ( ForwardIterator first, ForwardIterator last, const T& value ); 
	功能：使用value填充[first,last)之间内容。


random_shuffle()：有两个模板
	template <class RandomAccessIterator>
	void random_shuffle ( RandomAccessIterator first, RandomAccessIterator last );
	功能：将[first,last)之间的内容按照默认算法进行随机排序。

	template <class RandomAccessIterator, class RandomNumberGenerator>
	void random_shuffle ( RandomAccessIterator first, RandomAccessIterator last,
                    RandomNumberGenerator& rand );
	功能：将[first,last)之间的内容按照rand指定的随机序列号进行随机
		重新排序，需要自己实现rand函数。
		
		但是这个函数只能对数组/数组类型的容器如vector操作，对list操作
		无效，因为list等其它容器不支持随机访问。


 （2）例子
#include <iostream>
#include <algorithm>
#include<iterator>
#include<list>

using namespace std;
class Student {
public:
    	Student(const string name=" ", const string num=" "):name(name), num(num) { }

    	void setname(const string name) { this->name = name; }
    	void setnum(const string num) { this->num=num; }
    	string getname() const { return name; }
    	string getnum() const { return num; }
private:
    	string name;
    	string num;
};
class Trans_operate {
public:
    	Trans_operate(const string str=" "):str(str) {  }
    	Student *operator()(Student *op) {
            	Student *tmp = new Student(op->getname()+str, op->getnum()+str);
            	return tmp;
    	}
private:
    	const string str;
};

class Remove_operate {
public:
    	Remove_operate(const Student *stu, int optype):stu(stu), optype(optype) {  }
    	bool operator()(Student *op) {
            	if(1 == optype) return(op->getname()==stu->getname());
            	else if(2 == optype) return(op->getnum()==stu->getnum());
            	else return false;
    	}
private:
    	const Student *stu;
    	int optype;
};

int random_fun(int i) {
    	return (rand()%i);
}

/* 使用迭代器便利map */
template <class Iter> void show_list(Iter first, Iter last) {
    	for( ;first!=last; first++) {
            	cout << (*first)->getname() <<endl;
    	}
}

int main(void)
{
    	Student *stu[10] = {NULL};

    	/* 初始化对象数组 */
    	for(int i=0; i<sizeof(stu)/sizeof(stu[0]); i++) {
            	stu[i] = new Student(string("name")+string(1, i+'0'), string("11")+string(1, i+'0'));
    	}

    	/* 利用对象数组初始化list */
    	std::list<Student *> l1(stu, stu+sizeof(stu)/sizeof(stu[0]));
    	std::list<Student *> l2;
    	cout<<"\n交换l1和l2"<<endl;
    	swap(l1, l2);
    	if(!l1.empty()) {
            	cout<<"显示l1"<<endl;
            	show_list(l1.begin(), l1.end());
    	}
    	else cout<<"l1是空的"<<endl;
    	if(!l2.empty())  {
            	cout<<"显示l2"<<endl;
            	show_list(l2.begin(), l2.end());
    	}
    	else cout<<"l2是空的"<<endl;

    	cout<<"\n交换l1和l2后，l1变成了空，将l2的部分内容复制会l1"<<endl;
    	cout<<"但是由于l1变成了空，需要使用resize函数开辟需要的元素空间"<<endl;
    	l1.resize(l2.size()-2);
    	copy(++l2.begin(), --l2.end(), l1.begin());
    	cout<<"显示l1"<<endl;
    	show_list(l1.begin(), l1.end());
    	cout<<"显示l2"<<endl;
    	show_list(l2.begin(), l2.end());

    	cout<<"\n将l1中的对象深拷贝到l3中，需要自定义操作函数类"<<endl;
    	cout<<"要求l3容器不能为空"<<endl;
    	std::list<Student *> l3(l1.size());
    	transform(l1.begin(), l1.end(), l3.begin(), Trans_operate("**"));

    	cout<<"\n将l3中的[begin(), ++begin())替换l3begin()开始的元素"<<endl;
    	replace(l1.begin(), l1.end(), *(++l1.begin()), *(++l3.begin()));
    	cout<<"显示l1"<<endl;
    	show_list(l1.begin(), l1.end());

    	cout<<"\n按照条件删除元素"<<endl;
    	remove_if(l1.begin(), l1.end(), Remove_operate(new Student("name4", "111"), 1));
    	cout<<"显示l1"<<endl;
    	show_list(l1.begin(), l1.end());

    	cout<<"\n将l1[++++++l1.begin(), l1.end())的元素进行反转"<<endl;
    	reverse(++++++l1.begin(), l1.end());
    	cout<<"显示l1"<<endl;
    	show_list(l1.begin(), l1.end());

    	cout<<"\n将l2[l2.begin(), l2.end())的元素以++++++l2.begin()为中心进行rotate"<<endl;
    	rotate(l2.begin(), ++++++l2.begin(), l2.end());
    	cout<<"显示l2"<<endl;
    	show_list(l2.begin(), l2.end());

    	cout<<"\n将l2中[++++++l2.begin(), ------l2.end())使用new Student(\"wwwww\", \"999\")填充"<<endl;
    	fill(++++++l2.begin(), ------l2.end(), new Student("wwwww", "999"));
    	cout<<"显示l2"<<endl;
    	show_list(l2.begin(), l2.end());

    	ptrdiff_t (*p_myrandom)(ptrdiff_t) = random_fun;
    	cout<<"\n将stu中的元素按照自定义的方式随机化"<<endl;
    	random_shuffle(stu, stu+sizeof(stu)/sizeof(stu[0]), p_myrandom);
    	cout<<"显示stu"<<endl;
    	show_list(stu, stu+sizeof(stu)/sizeof(stu[0]));

    	return 0;
}

（5）排序相关的算法
（1）常见函数

sort()：有两个模板
	template <class RandomAccessIterator>
	void sort ( RandomAccessIterator first, RandomAccessIterator last );
	功能：将[first，last)之间的内容进行默认的升序排序，但是注意，只有
		基本类型有被提供默认的升序排序。
	
	template <class RandomAccessIterator, class Compare>
	void sort ( RandomAccessIterator first, RandomAccessIterator last, Compare comp );
 	功能：将[first，last)之间的内容进行自定义的排序，需要提供比较函数的
		函数对象。特别是如果容器中存放的类类型的数据来说，就必须提
		供自定义的比较函数对象，否者会导致编译不通过。
	
   注意：
	由于sort全局算法函数只支持随机迭代器，所以sort只能对数组和数组类型
	的容器比如vetor进行排序。
	
	如果希望对list按照自定义继续宁排序，需要调用list自己成员函数sort。
	
	对于关联容器map来说，只能在存入元素的时候进行排序，寻找一个合适
	的位置后将元素插入，所以只能在插入的时候排序，不能进行独立的排序。
	

stable_sort()：两个模板，与sort功能与参数同，唯一的区别是遇到相等元素时
	不会对其进行交换。

search()：有两个模板
	template <class ForwardIterator1, class ForwardIterator2>
	ForwardIterator1 search ( ForwardIterator1 first1, ForwardIterator1 last1,
                         ForwardIterator2 first2, ForwardIterator2 last2 );
	功能：在[firs,last)之间查询有没有[first，last2)元素序列，有的话，返回
		第一次出现的迭代器。注意与find区别，search查找的是一整块序列，
		而find查找的是序列中的一个或者元素有没有在容器中出现。			

	template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
	ForwardIterator1 search ( ForwardIterator1 first1, ForwardIterator1 last1,
                         ForwardIterator2 first2, ForwardIterator2 last2.
                         BinaryPredicate pred );
	功能：与上同，但是可以提供带两个参数的自定义比较函数。具体查阅函数手册

binary_search()：二分法查找，有两个模板
	template <class ForwardIterator, class T>
	bool binary_search ( ForwardIterator first, ForwardIterator last,
                   const T& value );
	功能：在[first， last)之间搜索value，找到返回true，失败返回false
		与前面讲解find_if函数功能基本相同，只是find_if如果成功，返回
		的是指向找到元素的迭代器，失败则返回end()。

	template <class ForwardIterator, class T, class Compare>
	bool binary_search ( ForwardIterator first, ForwardIterator last,
                   const T& value, Compare comp );

	指定比叫函数时，比较函数格式如下：
		bool myfunction (int op1,int op2) { return op1>op2); }
	其中op2时需要查找的元素。
		
	功能：与上同，但是可以指定自定义比较函数。比较函数格式请查阅手册

merge()：两个模板
	template <class InputIterator1, class InputIterator2, class OutputIterator>
	OutputIterator merge ( InputIterator1 first1, InputIterator1 last1,
                     InputIterator2 first2, InputIterator2 last2,
                     OutputIterator result );
	功能：将[first1, last1)和[firsr2, last2)之间的内容合并，合并时会
		按照默认排序函数进行排序，这只能针对基本类型操作。

	template <class InputIterator1, class InputIterator2,
      	class OutputIterator, class Compare>
	OutputIterator merge ( InputIterator1 first1, InputIterator1 last1,
                     InputIterator2 first2, InputIterator2 last2,
                     OutputIterator result, Compare comp );
	功能：同上，但是可以指定自定义的比较函数。



    备注：
	list也提供了一个属于自己的merge成员函数，利用该函数可以将其它链表合并到	
	自己中。使用全局的merge可以将两个链表合并到第三个链表中。

	这二者还有一个区别就是，list的merge函数合并成功后，被合并的list会被清空，
	但是全局的merge函数实现合并操作后，被合并的两个list不会被清空。


min()：经过比较后，返回最小值，有两个模板。
	template <class T> const T& min ( const T& a, const T& b );
	功能：返回最小值，调用默认比较函数（只对基本类型有效）。		

	template <class T, class Compare>
	const T& min ( const T& a, const T& b, Compare comp );
	功能：同上，可以提供自定义比较函数，对类类型对象操作时，必须使用
		这个模板，因为必须指定比较函数。
	
max()：功能与模板同min，只是返回的是最大的值。

		
   （2）演示例子
#include <iostream>
#include <algorithm>
#include<iterator>
#include<list>
#include<string.h>
#include<stdio.h>

using namespace std;
class Student { 
public:
    	Student(const string name=" ", const string num=" "):name(name), num(num) { } 

    	void setname(const string name) { this->name = name; }
    	void setnum(const string num) { this->num=num; }
    	string getname() const { return name; }
    	string getnum() const { return num; }
private:
    	string name;
    	string num;
};   

class Compare {
public:
    	Compare(int cmptype, int cmpoder):cmpoder(cmpoder), cmptype(cmptype) {  }
    	/* 如果是二分法binary_search函数调用比较函数，那么op2表示需要被查找的元素 */
    	bool operator()(Student *op1, Student *op2) {
            	cout <<op1<<endl;
            	cout <<op2<<endl;
            	cout <<op1->getname()<<endl;
            	cout <<op2->getnum()<<endl;
            	if(1 == cmptype) {//按照名字排序
                    	if(1 == cmpoder) {
                            	return(op1->getname() > op2->getname());
                    	} else if(2 == cmpoder) {
                            	return(op1->getname() < op2->getname());
                    	} else if(3==cmpoder) return(op1->getname() == op2->getname());
            	}
            	else if(2 == cmptype) {//按照学号排序
                    	if(1 == cmpoder) {
                            	return(op1->getnum() > op2->getnum());
                    	} else if(2 == cmpoder) {
                            	return(op1->getnum() < op2->getnum());
                    	} else if(3==cmpoder) return(op1->getnum() == op2->getnum());
            	} else return false;
    	}
private:
    	int cmpoder;
    	int cmptype;
};		
		
/* 使用迭代器便利map */
template <class Iter> void show_list(Iter first, Iter last) {
    	for( ;first!=last; first++) {
            	cout << (*first)->getname() << "   "<<(*first)->getnum()<<endl;
    	}
}
int main(void)
{
    	Student *stu[10] = {NULL};

    	/* 初始化对象数组 */
    	for(int i=0; i<sizeof(stu)/sizeof(stu[0]); i++) {
            	stu[i] = new Student(string("name")+string(1, i+'0'), string("11")+string(1, i+'0'));
    	}

   		/* 利用对象数组初始化list */
    	std::list<Student *> l1(stu, stu+sizeof(stu)/sizeof(stu[0]));

    	cout<<"\n对stu的内容按照要求排序"<<endl;
    	sort(stu, stu+sizeof(stu)/sizeof(stu[0]), Compare(2, 2));
    	show_list(stu, stu+sizeof(stu)/sizeof(stu[0]));

    	cout<<"\n全局sort不能对list进行排序，对list排序需要调用list的成员函数sort"<<endl;
    	l1.sort(Compare(1, 1));
    	show_list(l1.begin(), l1.end());

    	cout<<"\n在l2中搜索[++++l1.begin(), ------l1.end())区间的内容"<<endl;
    	std::list<Student*>::iterator it;
    	it = search(l1.begin(), l1.end(), ++++l1.begin(), ------l1.end(), Compare(2, 3));
    	if(it!=l1.end()) {
            	cout <<"找到,第一个元素是："<<endl;
            	cout <<(*it)->getname()<<"  "<<(*it)->getnum() <<endl;
    	}

    	cout<<"\n使用二分法在l2中按照要求查找new Student(\"name4\", \"111\")"<<endl;
    	bool ret = binary_search(l1.begin(), l1.end(), new Student("name4", "111"), Compare(2, 1));
    	cout << "ret = " << ret << endl;
    	if(ret) cout <<"找到"<<endl;
    	else cout <<"未找到"<<endl;

    	cout << "\n使用全局merge函数，将l1和l2合并到l3中，自定义合并后的排序顺序 " << endl;
    	std::list<Student *> l2(++++l1.begin(), ------l1.end());
    	std::list<Student *> l3(l1.size()+l2.size());
    	Student *stu3[13];
    	merge(l1.begin(), l1.end(), l2.begin(), l2.end(), l3.begin(), Compare(2, 2));
    	show_list(l3.begin(), l3.end());

    	cout << "\n调用l1的merge函数，将l2合并到自己空间中，使用自定义排序函数 " << endl;
    	l1.merge(l2, Compare(2, 2));
    	show_list(l1.begin(), l1.end());

    	cout << "\n比较*l1.begin(), *(++++l1.begin()谁最小，使用自定义比较函数比较"<<endl;
    	Student *p = min(*l1.begin(), *(++++l1.begin()), Compare(2, 2));
    	cout << p->getname()<<"   "<<p->getnum()<<endl;

    	cout << "\n比较*l1.begin(), *(++++l1.begin()谁最大，使用自定义比较比较"<<endl;
    	p = max(*l1.begin(), *(++++l1.begin()), Compare(2, 2));
    	cout << p->getname()<<"   "<<p->getnum()<<endl;

    	return 0;
}