排序算法——冒泡排序(Java&Python)

基本思想

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

code

JAVA

import java.util.Arrays;

public class BubbleSort {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = {49,38,65,97,76,13,27,49};
        int n = arr.length;
        for (int i=0;i<n-1;i++) {
            for (int j=0;j<n-1-i;j++) {
                if(arr[j]>arr[j+1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));

    }
}

Python

a = [49,38,65,97,76,13,27,49]
n = len(a)
for i in range(n-1):
    for j in range(n-1-i):
        if a[j]>a[j+1]:
            a[j],a[j+1] = a[j+1],a[j]
        j += 1
    i +=1
print(a)

冒泡算法的改进

对冒泡排序常见的改进方法是加入一标志性变量exchange，用于标志某一趟排序过程中是否有数据交换，如果进行某一趟排序时并没有进行数据交换，则说明数据已经按要求排列好，可立即结束排序，避免不必要的比较过程。本文再提供以下两种改进算法：

1．设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

改进后算法如下:

JAVA

    public static void Bubble_exc1(int[] arr,int n) {
        int i = n-1;
        while(i>0) {
            int pos = 0;
            for (int j=0;j<i;j++) {
                if(arr[j]>arr[j+1]) {
                    pos = j;//记录交换位置            
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
            i = pos;//为下一次准备
        }
    }

Python

def bubbleSort_1(arr,n):
    i = n-1
    while i>0:
        pos = 0
        for j in range(i):
            if a[j]>a[j+1]:
                pos = j
                arr[j],arr[j+1] = arr[j+1],arr[j]
        i = pos
    return arr

2．传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

改进后的算法实现为:

JAVA

public static void Bubble_exc2(int[] arr, int n) {
        int tmp_min = 0;
        int tmp_max = n-1;
        while(tmp_min<tmp_max) {
            for (int j = tmp_min;j<tmp_max;j++) {
                if(arr[j]>arr[j+1]) {           
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                    }
                tmp_max--;
            }

            for (int j = tmp_max;j>tmp_min;j--) {
                if(arr[j]<arr[j-1]) {           
                    int tmp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = tmp;
                    }
                tmp_min++;
            }
        }
    }

Python

def bubbleSort_2(arr,n):
    tmp_min = 0
    tmp_max = n-1
    while tmp_min<tmp_max:
        for j in range(tmp_min,tmp_max):
            if arr[j]>arr[j+1]:
                arr[j],arr[j+1] = arr[j+1],arr[j]
            tmp_max -= 1
        j = tmp_max
        while j>tmp_min:
            j -= 1
            if arr[j]<arr[j-1]:
                arr[j],arr[j-1] = arr[j-1],arr[j]
            tmp_min += 1
    return arr

时效

不稳定
最好时间复杂度：O(n)
最坏时间复杂度：O(n^2)

参考

http://blog.csdn.net/hguisu/article/details/7776068/

http://www.cnblogs.com/shen-hua/p/5422676.html