排序算法-冒泡排序及其优化

Weber77

已于 2022-04-17 00:07:45 修改

阅读量197

点赞数

于 2022-04-16 23:47:23 首次发布

本文链接：https://blog.csdn.net/ANobility/article/details/124223069

版权

排序算法专栏收录该内容

11 篇文章 0 订阅

订阅专栏

本文详细介绍了冒泡排序的三种实现方式：经典冒泡排序、优化冒泡排序1（通过标志位Flag优化）和优化冒泡排序2（使用position变量）。讨论了它们的时间复杂度和空间复杂度，并提供了Python和Java的代码实现。优化后的冒泡排序能有效减少不必要的比较和交换，提高排序效率。

摘要由CSDN通过智能技术生成

Bubble Sort

时间复杂度O(n**2)

最好情况O(n) // 已经排好序的数字

最坏情况O(n**2) //倒序数组

空间复杂度O(1) // in-place

经典冒泡排序

Python：

def Classical_bubble_sort(num_list):
    for i in range(len(num_list)):
        for j in range(len(num_list) - 1 - i):
            if num_list[j] > num_list[j + 1]:
                num_list[j], num_list[j + 1] = num_list[j + 1], num_list[j]
    return num_list

Java：

    public int[] ClassicalBubbleSort(int[] a){
        for(int i = 0;i<a.length;i++){
            for(int j = 0;j<a.length-1-i;j++){
                if (a[j]>a[j+1]){
                    int tem = a[j+1];
                    a[j+1] = a[j];
                    a[j] = tem;
                }
            }
        }
        return a;
    }

优化冒泡排序1

在经典冒泡排序的基础上增加了一个标志位Flag，若再一次内循环中Flag没有变化，则说明已经完成排序，可以直接退出。

Python：

def Optimized_bubble_sort(num_list):
    for i in range(len(num_list)):
        flag = 0
        for j in range(len(num_list) - 1 - i):
            if num_list[j] > num_list[j + 1]:
                num_list[j], num_list[j + 1] = num_list[j + 1], num_list[j]
                flag = 1
        if flag == 0:
            break

Java：

    public int[] OptimizedBubbleSort(int[] a){
        // Add a flag If no change in an iteration, bubble sort stop
        for(int i = 0;i<a.length;i++){
            int flag = 0;
            for(int j = 0;j<a.length-1-i;j++){
                if (a[j]>a[j+1]){
                    int tem = a[j+1];
                    a[j+1] = a[j];
                    a[j] = tem;
                    flag = 1;
                }
            }
            if (flag == 0){
                break;
            }
        }
        return a;
    }

优化冒泡排序2

再增加一个标志位position，用于记录一次位置交换最后发生的位置，说明该位置以后的数字已经有序无需交换，再下一次迭代时只需要内循环移动到 position的位置即可。

Python：

def Optimized_bubble_sort2(num_list):
    global position
    position_var = len(num_list)-1
    for i in range(len(num_list)):
        flag = 0
        for j in range(position_var):
            if num_list[j] > num_list[j + 1]:
                num_list[j], num_list[j + 1] = num_list[j + 1], num_list[j]
                flag = 1
                position = j
        if flag == 0:
            break
        position_var = position
    return num_list

Java：

    public int[] OptimizedBubbleSort2(int[] a){
        // add another position var, it records the last change position, and the next iteration will stop at the position
        int positionVar = a.length-1;
        int position = a.length-1;
        for(int i = 0;i<a.length;i++){
            int flag = 0;
            for(int j = 0;j<positionVar;j++){
                if (a[j]>a[j+1]){
                    int tem = a[j+1];
                    a[j+1] = a[j];
                    a[j] = tem;
                    flag = 1;
                    position = j;
                }
            }
            if (flag == 0){
                break;
            }
            positionVar = position;
        }
        return a;
    }