冒泡排序学习笔记

Posted 2021-04-07 药菌

1.冒泡排序原理

依次遍历要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从小到大）错误就把他们交换过来。重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。用双重的for循环来控制实现，一个变量i控制比较的趟数,一个变量j控制每趟比较的次数。冒泡排序算法最差时间复杂度O(n^2)，最优时间复杂度 O(n)，平均时间复杂度O(n^2)。

2.代码实现

 1//交换函数
 2template <class T>
 3void swap(T *a, T *b)
 4{
 5    T temp;
 6    temp = *a;
 7    *a = *b;
 8    *b = temp;
 9
10}
11
12//输出函数
13template <class T>
14void printArr(T *arr, int length)
15{
16    for (int i = 0; i < length; ++i)
17    {
18        cout << arr[i] << " ";
19    }
20    cout << endl;
21}

2.1 基本方法实现

 1template <class T>
 2void bubbleSort(T* arr, int length)
 3{
 4    for (int i = 0; i < length - 1; ++i)
 5    {
 6        for (int j = 0; j < length - 1 - i; ++j)
 7        {
 8            if (arr[j] > arr[j+1])
 9            {
10                swap(arr[j], arr[j + 1]);
11            }
12        }
13        cout << "第" << i << "次排序结果: ";
14        printArr(arr, 10);
15    }
16}

2.2 递归方法实现

 1template <class T>
 2void Recursive_bubbleSort(T *arr, int start, int end)
 3{
 4    if (start < end) 
 5    {
 6        int length = end - start + 1;
 7        for (int i = start-1; i < length - 1; i++)
 8        {
 9            if (arr[i] > arr[i + 1]) 
10            {
11                swap(arr[i], arr[i + 1]);
12            }
13        }
14        end--;
15        Recursive_bubbleSort(arr, start, end);
16    }
17}

2.3 第一种改进方法实现

里面一层循环在某次遍历中没有执行交换，则说明此时数组已经全部有序列，无需再遍历了。因此，增加一个标记，每次发生交换，就标记，如果某次循环完没有标记，则说明已经完成排序。

 1template <class T>
 2void OptimBubbleSort(T *arr, int length)
 3{
 4    for (int i = 0; i < length-1; ++i)
 5    {
 6        bool flag = true;
 7        for (int j = 0; j < length - 1 - i; ++j)
 8        {
 9            if (arr[j] > arr[j + 1])
10            {
11                swap(arr[j], arr[j + 1]);
12                flag = false;
13            }
14        }
15        if(flag)
16          break;
17        cout << "第" << i << "次排序结果: ";
18        printArr(arr, 10);
19
20    }
21
22}

2.3 第二种改进方法实现

标记每一次元素交换的位置，当元素交换的位置在第0个元素时，则排序结束。

 1template <class T>
 2void OptimBubbleSort1(T *arr, int length)
 3{
 4    int endLength = length - 1;  //endLength代表最后一个需要比较的元素下标
 5    while (endLength > 0)
 6    {
 7        int pos = 0;
 8        for (int j = 0; j < endLength; ++j)
 9        {
10            if (arr[j] > arr[j+1])
11            {               
12                swap(arr[j], arr[j + 1]);
13                pos = j+1;  //下标为j的元素与下标为j+1的元素发生了数据交换              
14            }
15        }
16        endLength = pos;  //下一轮排序时只对下标小于pos的元素排序，下标大于等于pos的元素已经排好
17    }       
18}