冒泡排序算法

冒泡排序算法

简单交换排序：       

首先介绍简单的交换排序，主要的思想是，在一个序列中k0...ki....kn。将第i位置处的数据与i位置之后的数据比较，最后达到i个位置处的数据是第i大或者第i小。java代码实现：

package com.tanghu.sort;
/*
 * 最简单的交换排序，在排序好前面的位置后对后面的数据的排序没有任何帮助，小的数据
 * 也有可能排在最后的位置上。
 */
public class SwapSort {
    public void swapSort(int array[]){
        for(int i=0;i<array.length;i++){
            for(int j=i+1;j<array.length;j++){
                if(array[i]>array[j]){
                    swap(array,i,j);
                }
            }
        }
    }
    public static void main(String args[]) {
        SwapSort swap = new SwapSort();
        int array[] = {2,4,3,5,7,2,-5,9,7,8};
        swap.swapSort(array);
        for(int a: array){
            System.out.println(a);
        }
    }
    private void swap(int array[], int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

这是最简单的排序算法，可见在排序好前面的位置后对后面的数据的排序没有任何帮助，小的数据也有可能排在最后的位置上。

冒泡排序：

冒泡排序的思想是，两两比较相邻的元素，如果反序则对两数据进行交换，直到没有反序为止。

java代码实现：

package com.tanghu.sort;

/*
 * 冒泡排序。对冒泡排序进行改进，当没有数据交换时说明后面的数据已经排好了顺序
 * 引入一个flag,冒泡排序的时间复杂度为O(n^2)
 */
public class BubbleSort {
    public void bubbleSort(int array[]) {
        boolean flag = true;
        for (int i = 0; i < array.length && flag == true; i++) {
            flag = false;
            for (int j = array.length - 2; j >= i; j--) {
                if (array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                    flag = true;
                }
            }
        }
    }
    private void swap(int array[], int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void main(String args[]) {
        BubbleSort bubble = new BubbleSort();
        int array[] = { 2, 4, 3, 5, 7, 2, -5, 9, 7, 8 };
        bubble.bubbleSort(array);
        for (int a : array) {
            System.out.println(a);
        }
    }
}

很显然，当不存在交换操作后，说明数据已经排好序，所以引入flag对冒泡排序进行优化。

冒泡排序是最简单的一种排序方法，分析一下它的时间复杂度。当最好的情况，也就是要排序的表本身就是有序的，那么我们比较次数，根据最后改进的代码，可以推断出就是n‐1次的比较，没有数据交换，时间复杂度为O(n)。当最坏的情况，即待排序表是逆序的情况，此时需要比较 次，并作等数量级的记录移动。因此，总的时间复杂度为O(n^2)。