冒泡排序

冒泡排序，即对相邻的元素进行两两比较，两个元素顺序相反的话，就进行交换；这样每经过一次排序就会将最小的或最大的元素“冒”到顶端，最终完成排序。

　　具体步骤：1）比较前后相邻的两个数据，如果前面的数据大于后面对数据，就将这两个数据进行交换；

　　　　　　　2）这样对数组的第0个数据到N-1个数据进行一次遍历后，最大一个数据就“沉”到数组的N-1个位置；

　　　　　　　3）N=N-1，如果N不等于0的话，就重复上述1）2）步骤，否则排序完成。

　　时间复杂度：若原数组本身就是有序的，仅需N-1次就可以完成排序；如果是倒序的比较次数为N-1+N-2+...+1=N(N-1)/2次，交换次数与比较次数等值。

　　　　　　　　冒泡排序的平均时间复杂度为：O(n^2)

　　空间复杂度：没有利用新的数组来辅助完成排序，冒泡排序的空间复杂度为O(1)

　　图解：

 

下面看一下具体实现的代码：

 

Java实现冒泡排序

　　　　1.第一种方法

public class BubbleSort {
　　public static void main(String[] args) {
　　　　int[] arr={6,3,8,2,9,1};
　　　　System.out.println("排序前数组为：");
　　　　for(int num:arr){
　　　　　　System.out.print(num+" ");
　　　　}
　　　　for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数
　　　　　　for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次
　　　　　　　　if(arr[j]>arr[j+1]){
　　　　　　　　　　int temp=arr[j];
　　　　　　　　　　arr[j]=arr[j+1];
　　　　　　　　　　arr[j+1]=temp;
　　　　　　　　}
　　　　　　}
　　　　} 
　　　　System.out.println();
　　　　System.out.println("排序后的数组为：");
 　　　　for(int num:arr){
 　　　　　　System.out.print(num+" ");
 　　　　} 
　　}
 }

 

　　　　2.第二种方法

public static void BubbleSort1(int [] a, int n){
    int i, j;
    for(i=0; i<n; i++){//表示 n 次排序过程。
        for(j=1; j<n-i; j++){
            if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换
                //交换 a[j-1]和 a[j]
                int temp;
                temp = a[j-1];
                a[j-1] = a[j];
                a[j]=temp;
            }
       } 
    } 
}    

 

C语言实现冒泡排序

#include <iostream>
void BubbleSort(int *arr,int n){
    for(int i=0;i<n;i++){
        int flag = 0;
        for(int j=0;j<n-1;j++){
            if(arr[j]>arr[j+1]){
                int t = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = t;
                flag = 1;
            }
        }
        if(!flag) break;
    }    
}
int main() {
    int arr[8] = {3,2,5,8,4,7,6,9};
    int n = 8;
    bubbSort(arr,n);
    for(int i=0;i<n;i++) {
        printf("%d ",arr[i]);
    }
    return 0;
}