排序2：自定义数据的排序（仿函数和lambda)

利用仿函数和泛型编程完成自定义数据的排序

template,class K>
void mysort(T & num,const K &cmp)
{
	int size = num.size();
	for (int i = 0; i <= size-2; i++)
	{
		for (int j = 0; j < size - i - 1; j++)
		{
			if (cmp(num[j],num[j+1]))
				swap(num[j], num[j + 1]);
		}
	}
}

借鉴stl的sort（C++98版本）

给mysort的判断条件提供仿函数接口（仿函数在C++中优化，速度和函数指针一样，避免命名污染，直接封装）

本例中，我们提供fun_cmp对象 利用重载operator（）来传入自定义比较方式。

例如，我想对pair二元组进行排序，要求升序且在first相等情况下，以second为主。

 

int flag=0;
#define   PAIR  pair
template
struct fun_cmp {
	bool operator()(const T a, const T b)const 
	{
		bool ret = a.first > b.first || (a.first == b.first && a.second > b.second);
		if (ret == true)
			flag ++;
		return ret;
	}
};
template
struct Big {
	bool operator()(const T a, const T b)const
	{
		return a>b;
	}
};

template
void mysort(vector & num,const K &cmp)
{
	int size = num.size();
	for (int i = 0; i <= size-2; i++)
	{
		for (int j = 0; j < size - i - 1; j++)
		{
			if (cmp(num[j],num[j+1]))
				swap(num[j], num[j + 1]);
		}
	}
}

using namespace std;
int main()
{
	vector v;
	PAIR p[] = { {2,4},{1,7}, {1, 2},{1,3},{1,-4},{2,7},{2,9} };
	for (int i = 0; i < sizeof(p) / sizeof(p[0]); i++)
	{
		v.push_back(p[i]);
	}
	p[0].first;
	mysort(v, fun_cmp());
	for (auto e : v)
	{
		printf("{%d,%d}  ", e.first, e.second);
	}
	cout << flag;

}

如果我们替换代码 ，使用struct，自定义对象 有四个依赖变量

那么

template,class K>
void mysort(T & num,const K &cmp)
{
	int size = num.size();
	for (int i = 0; i <= size-2; i++)
	{
		for (int j = 0; j < size - i - 1; j++)
		{
			if (cmp(num[j],num[j+1]))
				swap(num[j], num[j + 1]);
		}
	}
}
struct myvalue
{
	int a;
	int b;
	int c;
	int d;
};
void testMyvalue()
{
	class fun_value {
	public:
		bool operator()(myvalue first,myvalue second)const
		{
			bool ret = false;
			if(first.a==second.a)
			{
				if (first.b == second.b)
				{
					if (first.c ==second.c)
					{
						if (first.d == second.d)
						{
							return first.d > second.d;
						}
					}
					else
					{
						return first.c > second.c;
					}
				}
				else
				{
					return first.b > second.b;
				}
			}
			else
			{
				return first.a > second.a;
			}
			return ret;
		}

	};
	//自定义排序
	vector test;
	myvalue val[] = { {12,344,-6,-1}, {12,344,3,4},{2,3,5,6},{-22,2,-1,4},{24,243,43,4},{34,24,4,24},{12,344,3,4} };
	for (int i = 0; i < sizeof(val) / sizeof(val[0]); i++)
	{
		test.push_back(val[i]);
	}
	mysort/*>*/(test, fun_value());//自动推导类型
	for (auto e : test)
	{
		printf("{%d,%d,%d,%d}  ", e.a, e.b,e.c,e.d);
	}
}

当然这个参数还可以接受lambda表达式。

	mysort(test, [](const myvalue first, const myvalue second)->bool
	{
		if (first.a == second.a)
		{
			if (first.b == second.b)
			{
				if (first.c == second.c)
				{
					if (first.d == second.d)
					{
						return first.d > second.d;
					}
				}
				else
				{
					return first.c > second.c;
				}
			}
			else
			{
				return first.b > second.b;
			}
		}
		else
		{
			return first.a > second.a;
		}
	}
	);