一般冒泡排序(Bubble Sort)的写法

思路：

1. 每次迭代从第一个元素开始，依次选择相邻的元素比较大小，若两者顺序错误，则交换两者顺序。每一对元素都进行比较直至最后一对元素。
2. 下一次迭代也在原序列上进行重复的操作，除了最后一个元素不需要加入比较。
3. 重复上述步骤，直至没有元素对可以比较。

void Bubble_sort(vector<int>& v)
{
	int temp;
	for(int i = 0; i < v.size() - 1; ++i)
	{
		for(auto front = v.begin(), back = front + 1; front !=  v.end() - 1 - i; ++front, ++back)
			if(*front > *back)
			{
				temp = *front;
				*front = *back;
				*back = temp;
			} 
	}
}

优化一

假设我们的数组为【0,1,2,3,4,5,6,7,8,9】，则第一趟遍历即可完成元素之间的排序，就不需要进行多余的遍历了。所以我们可以在代码中加入flag标志，若当前遍历没有交换元素，则直接退出循环。

void Bubble_sort(vector<int>& v)
{
	int temp;
	bool flag = 0;
	for(unsigned int i= 0;  i < v.size() - 1; ++i)
	{
		for(auto front = v.begin(), back = front + 1; front != v.end() - 1 - i; ++front, ++back)
		{
			if(*front > *back)
			{
				temp = *front;
				*front = *back;
				*back = temp;
				flag = 1;
			}
		}
		if(flag == 0)
			return;
	}
}

优化二

优化一仅适用于遍历次数较少即可达到正序的数组，而对于前端乱序，后端正序的数组效率偏低（例如【1,2,4,0,3,5,6,7,8】），所以我们提出第二种优化方法:我们可以在每次遍历中使用迭代器end_pos标志最后一次交换的位置，下一次遍历的范围缩减到【v.begin()，end_pos）,这种优化方法对于上述特征的数组可以起到有效减少比较次数的优化作用。

void Bubble_sort(vector<int> &v)
{
	int temp;
	vector<int>::iterator back_end_pos = v.end() - 1;
	vector<int>::iterator back_pos;
	for(unsigned int i =0; i < v.size() - 1; ++i)
	{
		back_pos = v.begin();
		for(auto front = v.begin(), back = front + 1; front != back_end_pos; ++front,++back)
		{
			if(*front > *back)
			{
				temp = *front;
				*front = *back;
				*back = temp;
				back_pos = front;
			}
		}
		if(back_pos == v.begin())
			return;
		back_end_pos = back_pos;
	}
}

优化三

优化二的效率有很大的提升，还有一种优化方法可以继续提高效率。大致思想就是一次排序可以确定两个值，正向扫描找到最大值交换到最后，反向扫描找到最小值交换到最前面。例如：排序数据【1，2，3，4，5，6，0】

void Bubble_Sort(vector<int>& v)
{
	auto front_end_pos = v.begin();		//将小值往前推时，最后一次发生交换的位置
	auto back_end_pos = v.end() - 1;	//将大值往后推时，最后一次发生交换的位置
	vector<int>::iterator back_pos;	//将大值往后退时，用于记录最后一次交换的位置
	vector<int>::iterator front_pos = front_end_pos;	//将小值往前退时，用于记录最后一次交换的位置
	int temp;
	while(true)
	{
		back_pos = front_end_pos;
		for(auto front = front_end_pos, back = front + 1; front != back_end_pos; ++front, ++back)	//比较次数
		{
			if (*front > *back)
			{
				temp = *front;
				*front = *back;
				*back = temp;
				back_pos = front;
			}
		}
		if (back_pos == front_end_pos)
			return;
		back_end_pos = back_pos;

		front_pos = back_end_pos;
		for(auto back = back_end_pos; back != front_end_pos; --back)
		{
			auto front = back - 1;
			if (*front > *back)
			{
				temp = *front;
				*front = *back;
				*back = temp;
				front_pos = back;
			}
		}
		if (front_pos == back_end_pos)
			return;
		front_end_pos = front_pos;
	}
}