简单冒泡排序
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;
}
其实简单排序算法原理很简单,但是有很多地方可以优化,可以提高程序的性能,优化版本的冒泡排序在下一篇更新