冒泡排序算法

                                                                                        简单冒泡排序

 1.冒泡排序算法原理很简单   

          冒泡排序的思想比较简单，简而言之就是将元素一个个冒泡（沉底）到最前或者最后

          比如有一个序列   3    7     2     5     4     1     6

          逐个于相邻的下一个比较，如果不满足大于或者小于就交换，直到最后

          第一次排序后         3     2     5     4     1     6     7        //数字7沉底，交换了5次

          第二次排序后         2     3     4     1     5     6     7       //数字6沉底，交换了3次

          第三次排序后         2     3     1     4     5     6     7

          第四次排序后         2     1     3     4     5     6     7

          第五次排序后         1     2     3     4     5     6     7      //此时排序已经完成，不做优化的话，应该是还有一次的

           简单的冒泡是N-1次遍历，每次遍历长度为(N-第几次)，交换次数不确定

                           

  如下面表格中的数据，对于红色加粗的数据为每次沉底（冒泡）的数据，经过7次冒泡后，排序完成。这是最简单的冒泡，没有经过优化的，其实地5次冒                                       泡后，数据就排序完成了。

原始数据	1	7	6	2	5	4	3	8
第1次冒泡	1	6	2	5	4	3	7	8
第2次冒泡	1	2	5	4	3	6	7	8
第3次冒泡	1	2	4	3	5	6	7	8
第4次冒泡	1	2	3	4	5	6	7	8
第5次冒泡	1	2	3	4	5	6	7	8
第6次冒泡	1	2	3	4	5	6	7	8
第7次冒泡	1	2	3	4	5	6	7	8

 

简单排序的C++版实现

//程序不大，就都写头文件中了

#include <iostream>

template<typename T>
void show_array(T * arr, unsigned int n)
{
	for (unsigned int i = 0; i < n; ++i){
		std::cout << arr[i] << '\t';
	}
	std::cout << std::endl;
}



//先写个交换函数
template <typename T>
void swap(T & a, T & b)
{
	T t = a;		//若T是自定义类型，需要重载=函数实现深拷贝
	a = b;		//此次不用异或运算等方式是为了避免前拷贝
	b = t;
}


//再来一个比较函数less，作为默认的小于比较
template<typename T>
bool less(const T & a, const T & b)
{
	return a < b;
}

排序代码：

template<typename T>
void sort_bubble(T * arr, unsigned int n,
				bool(Less)(const T &, const T&) = less)	//默认排序比较
{
	//冒泡排序的思想比较简单，简而言之就是将元素一个个冒泡（沉底）到最前或者最后
	//比如有一个序列   3	7	2	5	4	1	6
	//逐个于相邻的下一个比较，如果不满足大于或者小于就交换，直到最后
	//第一次排序后		3	2	5	4	1	6	7		//数字7沉底，交换了5次
	//第二次排序后		2	3	4	1	5	6	7		//数字6沉底，交换了3次
	//第三次排序后		2	3	1	4	5	6	7
	//第四次排序后		2	1	3	4	5	6	7
	//第五次排序后		1	2	3	4	5	6	7		//此时排序已经完成，不做优化的话，应该是还有一次的
	//	简单的冒泡是 N-1次遍历，每次遍历长度为(N-第几次)，交换次数不确定


	//本来想用auto的，算了，还是不用C++11的新特性了
	for (unsigned int i = n - 1; i >0; --i){	//i==1的时候就结束了
		//	i控制沉底的位置，j控制遍历沉底
		for (unsigned int j = 0; j < i; ++j){
			//不满足小于就交换（其实等于可以不用交换）
			if (!less(arr[j], arr[j + 1])){
				swap(arr[j], arr[j + 1]);
			}// end if
		}//  end for j
		//打印一下过程
		show_array(arr, n);
	}// end for i
}

简单排序Java实现版:

public class BubbleSortUnOpt {
     
	public static void bullSort(int[] nums) {
		for(int i = nums.length - 1; i>=0; i--) {
			for(int j=0; j<=i; j++) {
				if(nums[j] > nums[i]) {
					swap(nums,j,i); // 交换位置
				}
			}
		}
	}
	
	private static void swap(int[] nums, int l, int r) {
		int temp = nums[l];
		nums[l] = nums[r];
		nums[r] = temp;
	}

其实简单排序算法原理很简单，但是有很多地方可以优化，可以提高程序的性能，优化版本的冒泡排序在下一篇更新