排序算法1——图解冒泡排序及其实现（三种方法，基于模板及函数指针）

排序算法1——图解冒泡排序及其实现（三种方法，基于模板及函数指针）
排序算法2——图解简单选择排序及其实现
排序算法3——图解直接插入排序以及折半（二分）插入排序及其实现
排序算法4——图解希尔排序及其实现
排序算法5——图解堆排序及其实现
排序算法6——图解归并排序及其递归与非递归实现
排序算法7——图解快速排序（两种主元选择方法）以及CUTOFF时间测试
排序算法8——图解表排序
排序算法9——图解桶排序及其实现
排序算法10——图解基数排序（次位优先法LSD和主位优先法MSD）
排序算法——比较与总结

---

冒泡排序是一种交换排序，基本思想是：
两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止
适用于数据量较小的排序

一、初级版

首先是代码和上下界的确定

初级版的思路是：
让每一个关键字，都和它后面的每一个关键字作比较，反序就交换。这样，第一位置的关键字在一次循环后一定变成最小值

可以看到，初级版的算法存在两个问题：
首先，它并不是真正意义上的冒泡排序算法，因为它不是两两相邻做比较的，只是最简单的交换顺序
其次，在排序过程中，做了很多多余的比较

---

二、升级版

---

三、加强版

这种加强版是基于第二个版本修改的，我们需要设置一个标志位
在发生交换的时候让标志位置位，如果标志位没有置位，就说明已经没有数据交换了，退出循环
举个例子，假如待排序的序列是{2,1,3,4,5,6,7,8,9}

可以看到，在第一趟结束后已经成为了一个有序的序列
也就是说在第二趟i = 1的时候，完全没有数据的交换
然后第三趟、第四趟一直到后面的第八趟，都没有发生数据交换。那么此时就可以设置一个标志位
如果在某一趟没有发生标志位的置位，就中断循环即可

分析一下该方法的时间复杂度：
最好的情况是本身就是有序的，比较的次数就是n-1次，没有数据的交换，时间复杂度为O（N）
最坏的情况是本身是逆序的，比较的次数就是∑（i-1）= n（n-1）/2，i从0到n-1，时间复杂度为O（N^2）
最后，它一定是适合数据量比较小的情况！

---

四、测试结果及代码

这里用到了3种版本的bubblesort，所以使用函数指针来实现

#include 

template<class T>
void BubbleSort0(T *a, int length) {
	for (int i = 0; i < length - 1; ++i) {
		for (int j = i + 1; j < length; ++j) {
			if (a[i] > a[j]) {
				T tmp;
				tmp = a[i];
				a[i] = a[j];
				a[j] = tmp;
			}
		}
	}
	ArrShow(a, length);
}

template<class T>
void BubbleSort1(T *a, int length) {
	for (int i = 0; i < length - 1; ++i) {
		for (int j = length - 2; j >= i; --j) {
			if (a[j] > a[j + 1]) {
				T tmp;
				tmp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = tmp;
			}
		}
	}
	ArrShow(a, length);
}

template<class T>
void BubbleSort2(T *a, int length) {
	bool flag = true;
	for (int i = 0; i < length - 1; ++i) {
		flag = false;
		for (int j = length - 2; j >= i; --j) {
			if (a[j] > a[j + 1]) {
				T tmp;
				tmp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = tmp;
				flag = true;
			}
		}
		if (flag == false)
			break;
	}
	ArrShow(a, length);
}

template<class T>
void ArrShow(T *a, int length) {
	for (int i = 0; i < length; ++i) {
		std::cout << a[i] << " ";
	}
	puts("\n");
}

template<class T>
void Bubble(T *arr, int len, char *mode, void (*func)(T *a, int length)) {
	puts(mode);
	func(arr, len);
}

int main(int argc, char *argv[]) {
	int test1[9] = { 9, 1, 5, 8, 3, 7, 4, 6, 2 };
	ArrShow(test1, 9);
	Bubble(test1, 9, "BubbleSort0 : ", BubbleSort0);

	int test2[9] = { 9, 1, 5, 8, 3, 7, 4, 6, 2 };
	Bubble(test2, 9, "BubbleSort1 : ", BubbleSort1);

	int test3[9] = { 9, 1, 5, 8, 3, 7, 4, 6, 2 };
	Bubble(test3, 9, "BubbleSort2 : ", BubbleSort2);
	
	return 0;
}

最终版代码

#include 
#include 

void Bublesort(int a[], int N) {
    if (N == 0 || N == 1)
        return;
    int end, j;
    bool flag = false;
    for (end = N - 1; end > 0; --end) {
        flag = false;
        for (j = 0; j < end; ++j) {
            if (a[j] > a[j + 1]) {
                int tmp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = tmp;   
                flag = true;       
            }
        }
        if (flag == false)
            break;
    }
}

void printArray(int a[], int N) {
    int i;
    for (i = 0; i < N; ++i) {
        printf("%d ", a[i]);
    }
    printf("\n");
}

int main (int argc, char* argv[]) {
    srand(time(NULL));
    int a[10] = {0};
    for (int i = 0; i < 10; ++i) {
        a[i] = rand() % 100 + 1;
    }
    printArray(a, 10);
    Bublesort(a, 10);
    printArray(a, 10);

    return 0;
}