经典排序算法(冒泡排序 Bubble Sort)注解及代码实现(c++、java)

冒泡排序

1.简介：冒泡排序(Bubble Sort)是一种简单的排序算法，通过重复的两两比较两个元素，若大小顺序关系不正确，则交换两个元素的位置，符合要求的元素会慢慢“浮”到数组顶端或尾端，故名冒泡排序。

2.算法思想：

       (1)两两比较相邻元素，若大小关系不合要求，交换两个数组元素。

       (2)从开始的第一对相邻元素到最后一对相邻元素，两两比较交换完后最后一个数将会是最大的元素。

       (3)除了最后一个元素对其余元素重复进行(1)、(2)步骤，直到数组整体有序。

3.示意：

/*假设数组元素为{1,3,5,2,7}*/

数组下标：       0     1     2     3     4

循环变量1                                    i

循环变量2         j    j+1

第1(1)次比较： 1     3     5     2     7    //因为   (arr[j]  = 1) <  (arr[j+1] = 3) ，故不交换

循环变量2                j     j+1

第1(2)次比较： 1     3     5     2     7    //因为   (arr[j]  = 3) <  (arr[j+1] = 5) ，故不交换

循环变量2                       j     j+1

第1(3)次比较:    1     3     5     2     7    //因为   (arr[j]  = 5) > (arr[j+1] = 2) ，交换

交换后序列:       1     3     2     5     7

循环变量2                              j     j+1

第1(4)次比较:    1     3     2     5     7    //因为   (arr[j]  = 5) <  (arr[j+1] = 7) ，故不交换

当前序列:          1     3     2     5     7

循环变量1                              i

循环变量2          j     j+1

第2(1)次比较:    1     3     2     5     7    //因为   (arr[j]  = 1) <  (arr[j+1] = 3) ，故不交换

循环变量2                j     j+1

第2(2)次比较:    1     3     2     5     7    //因为   (arr[j]  = 3) <  (arr[j+1] = 2) ，交换

交换后序列:       1     2     3     5     7

循环变量2                       j      j+1

第2(3)次比较:    1     2     3     5     7    //因为   (arr[j]  = 3) <  (arr[j+1] = 5) ，故不交换

(从此处已可以看出数组已经有序，但循环比较大小的过程还得继续，直到  i > 0 即 i == 1 的时候)

……………………直到  i > 0 即 i == 1 交换结束，数组有序。

从以上可以看出循环变量2始终小于循环变量1(即  j 始终小于 i ，以防止 j+1 的数组越界访问)  ，当 j 循环变量遍历完一次数组元素后，j 停留在  i - 1 位置，此时的  i  位置也即 j + 1 位置已经是最大，此次使 i - 1 继续进行下一次循环。

4.代码

(1) c++ 版

#include <iostream>
using namespace std ;

void bubble_Sort( int arr[] , int len , int start , int last ){
    for ( int i = len - 1 ; i > start ; i -- ){          ///限定冒泡排序范围，也就是使最后一个数始终为这个范围内最大的数
        for ( int j = 0 ; j < i ; j ++ ){                ///从开始的位置开始遍历
            if ( arr[j] > arr[j+1] ) swap( arr[j] , arr[j+1]) ;///从大到小排序
        }
    }
    return ;
}

int main(){
    int arr[5] = { 1 , 3 , 5 , 2 , 7 } ;
    bubble_Sort( arr , 5 , 0 , 5 ) ;
    for ( int i = 0 ; i < 5 ; i ++ ){
        cout << arr[i] << " " ;
    }
    cout << endl ;
    return 0 ;
}

(2) java 版

import java.util.Scanner;


public class Main{
	/*交换数组元素*/
	public static void swap( int[] arr , int i , int j ){
		int temp = arr[i] ;
		arr[i] = arr[j] ;
		arr[j] = temp ;
		return ;
	}
	
	public static void bubble_Sort( int[] arr , int start , int last ) {
		for ( int i = arr.length - 1 ; i > start ; i -- ) {
			for ( int j = 0 ; j < i ; j ++ ) {
				if ( arr[j] > arr[j+1] ) swap( arr , j , j + 1 ) ;
			}
		}
		return ;
	}
	
    public static void main(String[] args) {
    	Scanner sc = new Scanner(System.in) ;	
        int[] arr = {1,3,5,2,7} ;
       	bubble_Sort( arr , 0 , 5 ) ;
       	for ( int i = 0 ; i < arr.length ; i ++ ) {
       		System.out.print(arr[i]+" ") ;
        }
    }
}

5.算法时间复杂度简析

最坏时间复杂度:   O(n^2)        -------->   数组为 5  4  3  2  1 类似的情况为最差情况

最优时间复杂度:   O(n)            --------->   数组本身有序的情况 如  1  2  3  4  5 

平均时间复杂度:   O(n^2)

(若有不当之处，欢迎指出)