交换排序—冒泡排序

八大排序

交换排序：

交换排序的基本思想是：两两比较待排序的数据，发现两个数据的次序相反则进行交换，直到没有反序的数据为止。

1．冒泡排序的思想
平均时间复杂度：O(n²)
空间复杂度：O(1)
稳定性：稳定√

最多进行 n-1 趟排序，每趟排序时，从底部向上扫描，一旦发现两个相邻的元素不符合规则，则交换。我们发

现，第一趟排序后，最小值在 A[1]，第二趟排序后，较小值在 A[2]，第 n-1 趟排序完成后，所有元素完全按顺序排列。

2．排序过程示例

待排序数据：53 33 19 53 3 63 82 20 19 39 【底部】

---

第一趟排序：3 53 33 19 53 19 63 82 20 39

第二趟排序：3 19 53 33 19 53 20 63 82 39

第三趟排序：3 19 19 53 33 20 53 39 63 82

第四趟排序：3 19 19 20 53 33 39 53 63 82

第五趟排序：3 19 19 20 33 53 39 53 63 82

第六趟排序：3 19 19 20 33 39 53 53 63 82

第七趟排序：没有反序数据，排序结束。

3．程序代码

public class BubbleSort {
    public static void main(String[] args) {
        print();
        System.out.println();
        bubbleSort();
        print();
    }

    static int[]  data = {53,33,19,53,3,63,82,20,19,39};
    
    public static void bubbleSort(int []arr) {
        // 从前往后比 大的往后冒泡
        for(int i =0;i<arr.length-1;i++) {
            for(int j=0;j<arr.length-i-1;j++) {
                if(arr[j]>arr[j+1]) {
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
    
	public static void bubbleSort1(){
        int tmp = 0;
        for (int i = 0; i < data.length; i++) {
            // 从后往前比  小的数字往前冒泡
            for (int j = data.length-1; j > i; j--) {
                if (data[j] < data[j-1]){
                    tmp = data[j];
                    data[j] = data[j-1];
                    data[j-1] = tmp;
                }
            }
        }
    }
    public static void print(){
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + " ");
        }
    }
}

53 33 19 53 3 63 82 20 19 39 
3 19 19 20 33 39 53 53 63 82 

4．算法分析

（1）稳定性：稳定

（2）时间复杂度：

①原始数据正序，需一趟排序，比较次数 n-1=O(n)

②原始数据反序，需 n-1 趟排序，比较次数
$$\sum _{i=1}^{n-1}(n-i)=\frac{n(n-1)}{2}=O(n^2)$$
③一般情况下，虽然不一定需要 n-1 趟排序，但由于每次数据位置的改变需要 3 次移动操作，因此，总时间复

杂度高于直接插入排序。

（3）空间复杂度：仅需一个中间变量

5．改进

可以在每趟排序时，记住最后一次发生交换发生的位置，则该位置之前的记录均已有序。下一趟排序扫描到

该位置结束。利用这种方式，可以减少一部分比较次数。