冒泡排序

 

冒泡排序：

这可能是最简单的排序算法了，算法思想是每次从数组末端开始比较相邻两元素，把第i小的冒泡到数组的第i个位置。i从0一直到N-1从而完成排序。（当然也可以从数组开始端开始比较相邻两元素，把第i大的冒泡到数组的第N-i个位置。i从0一直到N-1从而完成排序。)

 

    两两相比较，最小的数到最上面
    data.length个数需比较data.length-1次

 

从头开始，把最大的冒到最后面

从尾开始，把最小的冒到最前面

 

冒头大尾小

 

冒泡排序及其复杂度分析

public void bubbleSort(int[] data) {

                      //比较的轮数
                    for (int i = 1; i < data.length; i++) {
                            //将相邻两个数进行比较，较大的数往后冒泡
                            for (int j = 0; j < data.length - i; j++) {
                                   if (data[j] > data[j + 1]) {
                                          //交换相邻两个数
                                          swap(data, j, j + 1);
                                   }
                            }
                     }
            printArray(data);//输出冒泡排序后的数组值
       }

 

package com.test;

public class Test {
	
	public static void main(String[] args) {
		int[] a = {9,1,5,2,10,8};
		
		bubbleSort1(a);	
		//bubbleSort2(a);	
		
		printArray(a);
	}
	
	
	public static void printArray(int[] a){
		for(int item : a){
			System.out.print(item + " ");
		}
	}
	
	//冒1
	public static void bubbleSort1(int[] a){
		if(a == null || a.length == 0){
			return;
		}
		
		for(int i=0 ; i< a.length-1 ; i++){
			for(int j=0;j< a.length-i-1;j++){
				if(a[j] > a[j+1]){
					int temp = a[j];
					a[j] = a[j+1];
					a[j+1] = temp;
				}
			}
		}
	}
	
	//冒2
	public static void bubbleSort2(int[] a){
		if(a == null || a.length == 0){
			return;
		}
		
		for(int i=0 ; i<a.length-1 ; i++){
			for(int j=i+1;j<a.length;j++){
				if(a[i] > a[j]){
					int temp = a[i];
					a[i] = a[j];
					a[j] = temp;
				}
			}
		}
	}
	
	/**  
	 * 反转数组的方法 
	 * @param data 
	 */  
	public static void reverse(int[] data) {  
	    int length = data.length;  
	    int temp = 0;// 临时变量  
	    for (int i = 0; i < length / 2; i++) {  
	        temp = data[i];  
	        data[i] = data[length - 1 - i];  
	        data[length - 1 - i] = temp;  
	    }  
	    printArray(data);// 输出到转后数组的值  
	}  
	
	public void swap(int[] a,int i,int j){
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}
	
}

 

 

问题1：

冒泡排序在最坏的情况下的比较次数是O(N^2) 

怎么有的就写冒泡排序在最坏情况下的比较次数是n(n-1)/2

 

一头雾水

 

答：

冒泡排序是一种用时间换空间的排序方法，最坏情况是把顺序的排列变成逆序，或者把逆序的数列变成顺序。在这种情况下，每一次比较都需要进行交换运算。举个例子来说，一个数列 5 4 3 2 1 进行冒泡升序排列，第一次大循环从第一个数（5）开始到倒数第二个数（2）结束，比较过程：先比较5和4，4比5小，交换位置变成4 5 3 2 1；比较5和3，3比5小，交换位置变成4 3 5 2 1……最后比较5和1，1比5小，交换位置变成4 3 2 1 5。这时候共进行了4次比较交换运算，最后1个数变成了数列最大数。

第二次大循环从第一个数（4）开始到倒数第三个数（2）结束。进行3次比较交换运算。

……

所以总的比较次数为 4 + 3 + 2 + 1 = 10次

对于n位的数列则有比较次数为 (n-1) + (n-2) + ... + 1 = n * (n - 1) / 2，这就得到了最大的比较次数

 

而O(N^2)表示的是复杂度的数量级。举个例子来说，如果n = 10000，那么 n(n-1)/2 = (n^2 - n) / 2 = (100000000 - 10000) / 2，相对10^8来说，10000小的可以忽略不计了，所以总计算次数约为0.5 * N^2。用O(N^2)就表示了其数量级（忽略前面系数0.5）。

 

 

复杂度分析：

 

时间复杂度：若给定的数组刚好是排好序的数组，采用改进后的冒泡排序算法，只需循环一次就行了，此时是最优时间复杂度：O(n)，若给定的是倒序，此时是最差时间复杂度：O(n2) ，因此综合平均时间复杂度为：O(n2)

 

空间复杂度：因为每次只需开辟一个temp的空间，因此空间复杂度是：O(1)