冒泡排序

冒泡排序，就是把待排序的元素看作是水中的泡泡，最大的元素上浮至数组末尾，次大元素上浮至倒数第二位，以此类推。若要从小到大排序，则从第一个元素开始与相邻元素进行比较，若大于相邻元素则交换，从而使得该元素“上浮”到排好序数组中应该放置的位置。

 

代码：

python:

def bubble_sort(li):
    for i in range(len(li)-1,0, -1):\\设数组长度是m
        for j in range(i):\\目前遍历至第n个元素，则第n个元素需要同其之后的m-n个元素进行比较
            if li[j] > li[j+1]:\\若当前元素大于其后一位的元素
                li[j], li[j+1] = li[j+1],li[j]\\交换相邻元素
    return li

 

JAVA:

public class bubble_sort {

       privateint[] li;

      

       publicbubble_sort(int[] li){

              this.li= li;

       }

 

       publicvoid sort(){

              for(inti=this.li.length-1; i>0; i--){

                     for(intj=0; j<i; j++){

                            if(this.li[j]> this.li[j+1]){

                                   intt = this.li[j];

                                   this.li[j]= this.li[j+1];

                                   this.li[j+1]= t;                              

                            }

                     }

              }

       }

}

 

C++:

void bubble_sort(int *li, int n){

       for(inti=n-1; i>0; i--){

              for(intj=0; j<i; j++){

                     if(li[j]> li[j+1]){

                            intt;

                            t= li[j];

                            li[j]= li[j+1];

                            li[j+1]= t;

                     }

              }

       }

}

 

时间复杂度分析： 若数组为正序数组，则冒泡排序仅需一次扫描即可完成排序，所需比较次数为n-1次，交换次数为0次。所以冒泡排序最好情况下的时间复杂度为O(n). 若数组为逆序数组，则需要n-1次排序，每次排序需要进行n-i次比较(1<=i<=n-1). 这种情况下比较次数和移动次数均为O(n²).

 

稳定性分析：由于冒泡排序仅在相邻元素间进行交换，因此排序后不会改变相同元素的先后顺序，所以冒泡排序是稳定的排序算法。