冒泡排序的实现和优化及其与插入，选择排序的比较

备注：这里使用的插入排序和选择排序都是经过优化后的详细优化请查看上一条博客，编译器使用DEV-C++

冒泡排序算法的运作如下：（从后往前）

1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3.针对所有的元素重复以上的步骤，除了最后一个。

4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

 

测试代码：

 1 #ifndef OPTIONAL_01_BUBBLE_SORT_SORTTESTHELPER_H
 2 #define OPTIONAL_01_BUBBLE_SORT_SORTTESTHELPER_H
 3 #include <iostream>
 4 #include <algorithm>
 5 #include <ctime>
 6 #include <string>
 7 #include <cassert>
 8 using namespace std;
 9  SortTestHelper {
10     // 生成有n个元素的随机数组,每个元素的随机范围为[rangeL,rangeR]
11     int *generateRandomArray(int n,int range_l,1)">int range_r) {
12         int *arr = new [n];
13         srand(time(NULL));
14         for (int i = 0; i < n; i++)
15             arr[i] = rand() % (range_r - range_l + 1) + range_l;
16         return arr;
17     }
18      生成一个近乎有序的数组
19      首先生成一个含有[0...n-1]的完全有序数组,之后随机交换swapTimes对数据
20      swapTimes定义了数组的无序程度
21     int *generateNearlyOrderedArray( swapTimes){
22         23         for(0 ; i < n ; i ++ )
24             arr[i] = i;
25 26         for( 0 ; i < swapTimes ; i ++ ){
27             int posx = rand()%n;
28             int posy = rand()%29             swap( arr[posx],arr[posy] );
30         }
31         32 33      拷贝整型数组a中的所有元素到一个新的数组,并返回新的数组
34     int *copyIntArray(int a[],1)"> n){
35         36         copy(a,a+n,arr);
37         38 39      打印arr数组的所有内容
40     template<typename T>
41     void printArray(T arr[],1)"> n) {
42         43             cout << arr[i] << " ";
44         cout << endl;
45         46 47      判断arr数组是否有序
48     template<typename T>
49     bool isSorted(T arr[],1)">50         0; i < n - 1; i++51             if (arr[i] > arr[i + 1])
52                 return false53         true54 55      测试sort排序算法排序arr数组所得到结果的正确性和算法运行时间
56     template<typename T>
57     void testSort(const string &sortName,1)">void (*sort)(T[],1)">int),T arr[],1)">58         clock_t startTime = clock();
59         sort(arr,n);
60         clock_t endTime =61         cout << sortName << " : " << double(endTime - startTime) / CLOCKS_PER_SEC <<  s"<<endl;
62         assert(isSorted(arr,n));
63         64 65 };
66 #endif

选择排序代码：

#ifndef OPTIONAL_01_BUBBLE_SORT_SELECTIONSORT_H
#define OPTIONAL_01_BUBBLE_SORT_SELECTIONSORT_H
 5  6 template<typename T>
 7 void selectionSort(T arr[],1)"> 8     ){
 9         int minIndex =10         int j = i + 1 ; j < n ; j ++11             if( arr[j] < arr[minIndex] )
12                 minIndex = j;
        swap( arr[i],arr[minIndex] );
14 15 }
16 #endif

插入排序代码：

#ifndef OPTIONAL_01_BUBBLE_SORT_INSERTIONSORT_H
#define OPTIONAL_01_BUBBLE_SORT_INSERTIONSORT_H
void insertionSort(T arr[],1)">1 ; i < n ; i ++ ) {
 9         T e = arr[i];
11         for (j = i; j > 0 && arr[j-1] > e; j--12             arr[j] = arr[j-];
13         arr[j] = e;
15     #endif 

冒泡排序以及优化代码：

  1 #include <iostream>
  2 #include <algorithm>
  3 #include SortTestHelper.h"
  4 #include SelectionSort.h  5 #include InsertionSort.h  6   7  第一版bubbleSort
  8 template<typename T>
  9 void bubbleSort( T arr[],1)"> 10     bool swapped;
 11     do{
 12         swapped =  13          14             if( arr[i-1] > arr[i] ){
 15                 swap( arr[i-],arr[i] );
 16                 swapped =  17             }
 18          优化,每一趟Bubble Sort都将最大的元素放在了最后的位置
 19          所以下一次排序,最后的元素可以不再考虑
 20         n -- 21     }while(swapped);
 22  23  第二版bubbleSort,使用newn进行优化
 24 template<typename T>
 25 void bubbleSort2( T arr[],1)"> 26     int newn;  使用newn进行优化
 27      28         newn = 0 29          30              31                 swap( arr[i- 32                  记录最后一次的交换位置,在此之后的元素在下一轮扫描中均不考虑
 33                 newn = 34  35         n = newn;
 36     }while(newn > );
 37  38  main() {
 39     int n = 20000 40      测试1 一般测试
 41     cout<<Test for random array,size = "<<n<<,randome range [0,] 42     int *arr1 = SortTestHelper::generateRandomArray(n, 43     int *arr2 = SortTestHelper::copyIntArray(arr1,1)"> 44     int *arr3 = 45     int *arr4 = 46 
 47     SortTestHelper::testSort(Selection Sort 48     SortTestHelper::testSort(Insertion Sort 49     SortTestHelper::testSort(Bubble Sort 50     SortTestHelper::testSort(Bubble Sort 2 51 
 52     delete[] arr1;
 53     [] arr2;
 54     [] arr3;
 55     [] arr4;
 56 
 57     cout<< 58      测试2 测试近乎有序的数组
 59     int swapTimes = 100 60     cout<<Test for nNearly ordered array,swap time = "<<swapTimes<< 61     arr1 = SortTestHelper::generateNearlyOrderedArray(n,swapTimes);
 62     arr2 = 63     arr3 = 64     arr4 = 65 
 66     SortTestHelper::testSort( 67     SortTestHelper::testSort( 68     SortTestHelper::testSort( 69     SortTestHelper::testSort( 70 
 71      72      73      74      75 
 76     cout<< 77      测试3 测试完全有序的数组
 78      对于完全有序的数组，冒泡排序法也将成为O(n)级别的算法
 79     swapTimes =  80     n = 10000000;     由于插入排序法和冒泡排序法在完全有序的情况下都将成为O(n)算法
 81                       所以我们的测试数据规模变大，为1000,0000
 82     cout<<Test for ordered array,1)">" << n << 83 
 84     arr1 = 85     arr2 = 86     arr3 = 87     arr4 = 88 
 89      在这种情况下，不再测试选择排序算法
 90     SortTestHelper::testSort("Selection Sort",n);
 91     SortTestHelper::testSort( 92     SortTestHelper::testSort( 93     SortTestHelper::testSort( 94 
 95      96      97      98      99     return 100 }

测试结果: