冒泡排序BubbleSort

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

1、算法思想

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

2、对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。

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

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

即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。

2、代码实现

public static void bubbleSort(int[] source) {
        int length = source.length;
        for (int i = 0; i < length - 1; i++) { // N个数需N-1趟,每趟完成之后,较大元素将冒到数组最末端
            for (int j = 0; j < length - 1 - i; j++) { // 每趟需要比较N-i次比较
                if (source[j] > source[j + 1]) {
                    swap(source, j, j + 1);
                }
                // System.out.print("\n外循环第" + (i + 1) + "次,内循环第" + (j + 1) + "次,排序结果:");
                // printArray(source);
            }
            System.out.println("");
        }
    }

3、算法分析

算法稳定性

        冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。所以,如果两个元素相等,我想你是不会再无聊地把他们俩交换一下的;如果两个相等的元素没有相邻,那么即使通过前面的两两交换把两个相邻起来,这时候也不会交换,所以相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。

4、算法改进

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

本文再提供以下两种改进算法:

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

改进后算法如下:

 /**
     * 设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。
     *
     * 由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。
     */
    public static void bubbleSort2(int[] source) {
        int high = source.length - 1;
        while (high > 0) { // high=0时证明最后一次进行交换的位置为0
            int pos = 0;// 每趟开始,无记录交换
            for (int i = 0; i < high; i++) {
                if (source[i] > source[i + 1]) {
                    swap(source, i, i + 1);
                    pos = i; // 有交换则令pos=i
                }
            }
            high = pos; // 每趟for循环结束,pos、length变更一次
            // System.out.println(high);
        }
    }

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

改进后的算法实现为:

/**
     * 每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大值和最小值),
     *
     * 从而使排序趟数几乎减少了一半。
     */
    public static void bubbleSort3(int[] source) {
        int low = 0;
        int high = source.length - 1;
        while (low < high) {
            for (int i = low; i < high; i++) { // 正向找最大
                if (source[i] > source[i + 1]) {
                    swap(source, i, i + 1);
                }
            }
            high--; // 一次for循环结束,最大数冒出
            for (int i = high; i > low; i--) { // 逆向找最小
                if (source[i] < source[i - 1]) {
                    swap(source, i, i - 1);
                }
            }
            low++;
        }
    }

swap

private static void swap(int[] source, int x, int y) {
        int temp = source[x];
        source[x] = source[y];
        source[y] = temp;
    }

源码地址:https://github.com/zxiaofan/Algorithm/blob/master/src/sort/BubbleSort.java

时间: 2024-08-03 21:06:24

冒泡排序BubbleSort的相关文章

JavaScript版几种常见排序算法分享

说明 ·  每个浏览器测试得出的数据会不一样.比如我用chrome 测试 一般快速排序都会最快,IE 则根据数组长度有可能希尔最快. ·  不要用太大数据去测试冒泡排序(浏览器崩溃了我不管) 个人理解 ·  冒泡排序:最简单,也最慢,貌似长度小于7最优 ·  插入排序: 比冒泡快,比快速排序和希尔排序慢,较小数据有优势 ·  快速排序:这是一个非常快的排序方式,V8的sort方法就使用快速排序和插入排序的结合 ·  希尔排序:在非chrome下数组长度小于1000,希尔排序比快速更快 ·  系统

c++ c-oj 题聪明的员工怎么做?

问题描述 oj 题聪明的员工怎么做? 题目描述 小新是一家公司的员工,每个员工都有一个编号.每天上班时,老板都让员工排成一个队伍.但是,每次老板都对队伍的顺序不满意,于是老板重新编排新的队伍顺序,然后让员工按顺序排好.老板有特别要求,队伍每次只能将其中一个人移动到队头.聪明的小新很快想到最少移动次数使得队伍的顺序跟老板指定的顺序一样.愚蠢的老板不清楚小新是怎么做到的,聪明的你编写程序告诉ta. 输入 第一行是T(T<=10),代表数据的组数. 对于每组数据,第1行是一个整数n(2<=n<

js常用的数组元素排序算法(冒泡 插入 希尔)(1/2)

下面来看看网页特效中常用的一些排序方法 ,我们主要是包括有冒泡 插入 希尔排序方法 ,主要是针对数组操作.     // ---------- 一些排序算法     // js 利用sort进行排序      systemsort:function(array){         return array.sort(function(a, b){             return a - b;         });     },     // 冒泡排序      bubblesort:fu

js的各种排序算法实现(总结)_javascript技巧

如下所示: // ---------- 一些排序算法 var Sort = {} Sort.prototype = { // 利用sort进行排序 systemSort:function(array){ return array.sort(function(a, b){ return a - b; }); }, // 冒泡排序 bubbleSort:function(array){ var i = 0, len = array.length, j, d; for(; i<len; i++){ f

JavaScript中几种常见排序算法小结_javascript技巧

说明 写这个主要是为了锻炼自己,并无实际意义. 每个浏览器测试得出的数据会不一样.比如我用chrome 测试 一般快速排序都会最快,IE 则根据数组长度有可能希尔最快. 不要用太大数据去测试冒泡排序(浏览器崩溃了我不管) 如果有兴趣可以 下载测试页面 个人理解 冒泡排序:最简单,也最慢,貌似长度小于7最优 插入排序: 比冒泡快,比快速排序和希尔排序慢,较小数据有优势 快速排序:这是一个非常快的排序方式,V8的sort方法就使用快速排序和插入排序的结合 希尔排序:在非chrome下数组长度小于10

javascript数组排序汇总_javascript技巧

javascript数组排序汇总 //排序算法 window.onload = function(){ var array = [0,1,2,44,4, 324,5,65,6,6, 34,4,5,6,2, 43,5,6,62,43, 5,1,4,51,56, 76,7,7,2,1, 45,4,6,7,8]; //var array = [4,2,5,1,0,3]; console.log('原始数组'); console.log(array); array = sorting.shellSort

JS数组排序技巧汇总(冒泡、sort、快速、希尔等排序)_javascript技巧

本文实例总结了JS数组排序技巧.分享给大家供大家参考,具体如下: ① 冒泡排序 bubbleSort:function(array){ var i = 0, len = array.length, j, d; for(; i<len; i++){ for(j=0; j<len; j++){ if(array[i] < array[j]){ d = array[j]; array[j] = array[i]; array[i] = d; } } } return array; } ② js

操作数组的常用方式二-----排序、查找

/** * 操作数组的常用方式 */ public class ArrayDemo { public static void main(String[] args) { int[] arr = new int[] { 1, 3, 10, 2, 5, 7, 8 }; // 排序前 System.out.println("--------------------排序前--------------------"); printArray(arr); // 选择排序 // selectSort

Javascript中的常见排序算法_javascript技巧

具体代码及比较如下所示: 复制代码 代码如下: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  <html xmlns="http://www.w3.org/1999/xhtml" lang="gb2312">