Java冒泡排序

冒泡排序

冒泡排序Bubble Sort)是一种简单直观的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

算法步骤

1)比较相邻的元素。如果第一个比第二个大,就交换他们两个。

2)对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。

3)针对所有的元素重复以上的步骤,除了最后一个。

4)持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

算法图示

算法基本性能

排序算法 平均情况 最好情况 最坏情况 控件复杂度 稳定性
冒泡排序 O(n2) O(n)(优化的版本) O(n2) O(1) 稳定

Java代码

按照定义的版本,每一次交换相邻的两个元素(优化前)

package com.sort;

import java.util.Random;

public class Main4 {

    // 从小到大
    private static void sort(int[] array) {
        if (array.length <= 1) {
            return;
        }
        for (int i = 0; i < array.length - 1; i++) {
            /**
             * 范围逐步缩小
             */
            for (int j = 1; j < array.length - i; j++) {
                if (array[j - 1] > array[j]) {
                    int temp = array[j];
                    array[j] = array[j - 1];
                    array[j - 1] = temp;
                }
            }
        }
    }

    /**
     * 获取指定长度的随机数组
     */
    public static int[] getRandomArray(int n) {
        int[] array = new int[n];
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(500);
        }
        return array;
    }

    /**
     * 打印指定数组
     */
    public static void outputArray(int[] array) {
        for (int i : array) {
            System.out.print(i + " ");
        }
        System.out.println("");
    }

    public static void main(String[] args) {
        int[] array = getRandomArray(10);
        outputArray(array);
        sort(array);
        outputArray(array);
    }
}

在上面的算法性能中我们可以看到,冒泡排序最好的时间复杂度是O(n),也就是在排序之前,已经有序了,如果采用上面的代码,那么时间复杂度还是O(n2)。还有一种普遍的情况是,如果有100个数的数组,仅前面10个无序,后面90个都已排好序且都大于前面10个数字,那么在第一趟遍历后,最后发生交换的位置必定小于10,且这个位置之后的数据必定已经有序了,记录下这位置,第二次只要从数组头部遍历到这个位置就可以了。

Java冒泡排序针对排序之前数据部分有序优化。

// 从小到大
    private static void sort(int[] array) {
        if (array.length <= 1) {
            return;
        }
        // flag为最后一次交换的位置
        int flag = array.length;
        while (flag > 0) {
            // k保存上一最后交换的位置
            int k = flag;
            flag = 0;
            // 一直比较相邻元素到上一次最后交换的位置
            for (int i = 1; i < k; i++) {
                if (array[i - 1] > array[i]) {
                    int temp = array[i];
                    array[i] = array[i - 1];
                    array[i - 1] = temp;
                    // 每一次交换都记录下交换的位置,那么最后留下的就是最后一次交换的位置
                    flag = i - 1;
                }
            }
        }
    }

参考博客:快客网CSDN

posted @ 2016-08-19 15:06  27House  阅读(275)  评论(0编辑  收藏  举报