【C++】泛型的冒泡排序

1.普通的整型冒泡排序

void BubbleSort(int *a,int size)
{
	int k = 0;
	for (int i = 0; i < size - 1; i++)
	{
		for (int j = 0; j < size - 1 - i; j++)
		{
			if (a[j]<a[j + 1])
			{
				k = a[j];
				a[j] = a[j + 1];
				a[j + 1] = k;
			}
		}
	}
}

2.上面的函数只能对整数进行排序，而且只能按照降序排列，我们可以通过泛型编程的形式实现一个可以对多种类型进行排序的函数

enum         //枚举类型
{
	Desc  //降序 0
	,Asc  //升序 1
};
template <class T>              //泛型可指定升降序的冒泡排序
void Sortbubble(T *a,int size,bool ret=1)
{
	int k;
	if (ret==0)
	{
		for (int i = 0; i < size - 1; i++)
		{
			for (int j = 0; j < size - 1 - i; j++)
			{
				if (a[j]<a[j + 1])
				{
					k = a[j];
					a[j] = a[j + 1];
					a[j + 1] = k;
				}
			}
		}
	}
	else
	{
		for (int i = 0; i < size - 1; i++)
		{
			for (int j = 0; j < size - 1 - i; j++)
			{
				if (a[j]>a[j + 1])
				{
					k = a[j];
					a[j] = a[j + 1];
					a[j + 1] = k;
				}
			}
		}
	}
}

测试上述函数

int main()
{
	int arr[] = { 9, 8, 0, 7, 6, 5, 4, 3, 2, 1 };
	Sortbubble(arr, sizeof(arr) / sizeof(arr[0]),Desc);    //降序排列
	//Sortbubble(arr, sizeof(arr) / sizeof(arr[0]), Asc);    //升序排列
	//Sortbubble(arr, sizeof(arr) / sizeof(arr[0]));  
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;

	char arr2[] = "cbadfe";
	Sortbubble(arr2, strlen(arr2),Desc);
	cout << arr2 << endl;

	double arr3[]={6.5,4.3,8.5,1.2,4.1};
	Sortbubble(arr3,sizeof(arr3) / sizeof(arr3[0]));
	for (int i = 0; i < 5; i++)
	{
		cout << arr3[i] << " ";
	}
	cout << endl;

	system("pause");
	return 0;
}

结果为

3.上述函数的代码复用率不高，升序与降序只有一个符号不同，我们可以再写一个可以排升序降序、多种类型数据并且代码复用率高的函数

template<class T>
struct Less   //降序
{
	bool operator()(const T&left,const T&right)
	{
		if (left < right)
			return true;
		return false;
	}
};
template<>       //特化降序类，使指针数组类型也可以传参进行排序
struct Less<char*>
{
	bool operator()(const char*left,const char*right)
	{
		if (strcmp(left,right)<0)
			return true;
		return false;
	}
};
template<class T>
struct Rise
{
	bool operator()(const T&left,const T&right)
	{
		if (left>right)
			return true;
		return false;
	}
};

template<>             //特化降序类，使指针数组类型也可以传参进行排序
struct Rise<char*>
{
	bool operator()(const char*left,const char*right)
	{
		if (strcmp(left,right)>0)
			return true;
		return false;
	}
};

template <class T,class Compare>
void BubbleSort(T*arr, int size)
{
	if (arr == NULL)
		return;
	bool IsChange = false;
	for (int i = 0; i < size - 1; i++)
	{
		IsChange = false;
		for (int j = 0; j < size - i - 1; j++)
		{
			if (Compare()(arr[j], arr[j + 1]))    //Compare是一个类型 ；（）是函数名 ； （arr[j],arr[j+1]）是参数
			{
				IsChange = true;
				swap(arr[j], arr[j + 1]);
			}
		}
		if (IsChange == false)
			return;
	}
}

测试函数

int main()
{

	char arr[] = "acdbfe!";
	BubbleSort<char, Rise<char>>(arr, 7);

	string arr1[] = { "cde", "fbi", "kmj" };
	BubbleSort<string, Less<string>>(arr1, 3);

	int arr2[] = { 3, 2, 4, 1, 5, 7, 6, 8, 0, 9 };
	BubbleSort<int, Rise<int>>(arr2, sizeof(arr2) / sizeof(arr2[0]));

	char*p[] = { "cd", "acd", "bcd" };
	BubbleSort<char*, Less<char*>>(p, 3);

	system("pause");
	return 0;
}

第三种用到了函数模板，类模板，还有特化函数，如果看不懂的话可以查找C++中模板，特化函数的知识点