冒泡排序

于 2016-02-29 09:05:22 发布 560 收藏
分类专栏： Java基础 文章标签： 冒泡排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25371579/article/details/50763111
版权

排序

排序：将一组数据按相应的规则排序顺序。

1、规则：

基本数据类型：
引用数据类型：
a) 内置类(String、Integer等)，内部已经指定规则，直接使用即可
b) 自定义类，需要按业务规则排序

2、顺序：

升序 从小到大
降序 从大到小

3、排序：

算法：如 冒泡、选择、插入shell、堆 等等

冒泡排序

简易版：简单
优化版：减少每趟次数
最终版：考虑有序，减少趟数

冒泡排序分析：

对9 8 7 6 5进行有小到大排序

每趟找到该趟最大的数

第一趟：找出最大的数 9
   第一次： 8 9 7 6 5 (9与8交换)
   第二次： 8 7 9 6 5 (9与7交换)
   第三次： 8 7 6 9 5 (9与6交换)
   第四次： 8 7 6 5 9 (9与5交换)
第二趟：找出最大的数 8
   第一次： 7 8 6 5 9 (8与7交换)
   第二次： 7 6 8 5 9 (8与6交换)
   第三次： 7 6 5 8 9 (8与5交换)
   第四次： 7 6 5 8 9 (8与9交换)
第三趟：找出最大的数 7
   第一次： 6 7 5 8 9 (7与6交换)
   第二次： 6 5 7 8 9 (7与5交换)
   第三次： 6 5 7 8 9 (7与8交换)
   第四次： 6 5 7 8 9 (8与9交换)
第四趟：找出最大的数 6
   第一次： 5 6 7 8 9 (6与5交换)
   第二次： 5 6 7 8 9 (6与7交换)
   第三次： 5 6 7 8 9 (7与8交换)
   第四次： 5 6 7 8 9 (8与9交换)

BubbleSort01.java

package com.matrix.sort.bubble;

import java.util.Arrays;

/**
 * 冒泡排序
 * 
 * BubbleSort1<BR>
 * 创建人:Matrix <BR>
 * 时间：2016年2月28日-下午5:35:46 <BR>
 * 
 * @version 1.0.0
 *
 */
public class BubbleSort01 {

    public static void main(String[] args) {

        int[] arr = { 9, 8, 7, 6};

        System.out.println("第一趟第一次");
        // 第一趟 第一次
        int i = 0;
        if (arr[i] > arr[i + 1]) {
            int temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
        System.out.println(Arrays.toString(arr));

        System.out.println("第一趟第二次");
        // 第一趟 第二次
        i++;
        if (arr[i] > arr[i + 1]) {
            int temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
        System.out.println(Arrays.toString(arr));

        System.out.println("第一趟第三次");
        // 第一趟 第二次
        i++;
        if (arr[i] > arr[i + 1]) {
            int temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
        System.out.println(Arrays.toString(arr));

    }
}

运行结果：

第一趟第一次
[8, 9, 7, 6]
第一趟第二次
[8, 7, 9, 6]
第一趟第三次
[8, 7, 6, 9]

改进版2.0

BubbleSort02.java

package com.matrix.sort.bubble;

import java.util.Arrays;

/**
 * 冒泡排序
 * 
 * BubbleSort1<BR>
 * 创建人:Matrix <BR>
 * 时间：2016年2月28日-下午5:35:46 <BR>
 * 
 * @version 1.0.0
 *
 */
public class BubbleSort02 {

    public static void main(String[] args) {
        int[] arr = { 9, 8, 7, 6, 5 };
        sortSecond(arr);
    }

    public static void sortFirst(int[] arr) {
        System.out.println("第一趟");
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.println("第" + (i + 1) + "次");
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
            System.out.println(Arrays.toString(arr));
        }
    }

    public static void sortSecond(int[] arr) {
        System.out.println("第一趟");
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.println("第" + (i + 1) + "次");
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
            System.out.println(Arrays.toString(arr));
        }
        System.out.println("第二趟");
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.println("第" + (i + 1) + "次");
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
            System.out.println(Arrays.toString(arr));
        }
        System.out.println("第三趟");
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.println("第" + (i + 1) + "次");
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
            System.out.println(Arrays.toString(arr));
        }
        System.out.println("第四趟");
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.println("第" + (i + 1) + "次");
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
            System.out.println(Arrays.toString(arr));
        }
    }
}

运行结果：

第一趟
第1次
[8, 9, 7, 6, 5]
第2次
[8, 7, 9, 6, 5]
第3次
[8, 7, 6, 9, 5]
第4次
[8, 7, 6, 5, 9]
第二趟
第1次
[7, 8, 6, 5, 9]
第2次
[7, 6, 8, 5, 9]
第3次
[7, 6, 5, 8, 9]
第4次
[7, 6, 5, 8, 9]
第三趟
第1次
[6, 7, 5, 8, 9]
第2次
[6, 5, 7, 8, 9]
第3次
[6, 5, 7, 8, 9]
第4次
[6, 5, 7, 8, 9]
第四趟
第1次
[5, 6, 7, 8, 9]
第2次
[5, 6, 7, 8, 9]
第3次
[5, 6, 7, 8, 9]
第4次
[5, 6, 7, 8, 9]

改进版3.0

BubbleSort03.java

package com.matrix.sort.bubble;

import java.util.Arrays;

/**
 * 冒泡排序
 * 
 * BubbleSort1<BR>
 * 创建人:Matrix <BR>
 * 时间：2016年2月28日-下午5:35:46 <BR>
 * 
 * @version 1.0.0
 *
 */
public class BubbleSort03 {

    public static void main(String[] args) {
        int[] arr = { 9, 8, 7, 6, 5 };
        sort(arr);
    }

    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.println("【第" + (i + 1) + "趟】");
            for (int j = 0; j < arr.length - 1; j++) {
                System.out.println("第" + (j + 1) + "次");
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
                System.out.println(Arrays.toString(arr));
            }
            System.out.println("");
        }
    }

}

运行结果：

【第1趟】
第1次
[8, 9, 7, 6, 5]
第2次
[8, 7, 9, 6, 5]
第3次
[8, 7, 6, 9, 5]
第4次
[8, 7, 6, 5, 9]

【第2趟】
第1次
[7, 8, 6, 5, 9]
第2次
[7, 6, 8, 5, 9]
第3次
[7, 6, 5, 8, 9]
第4次
[7, 6, 5, 8, 9]

【第3趟】
第1次
[6, 7, 5, 8, 9]
第2次
[6, 5, 7, 8, 9]
第3次
[6, 5, 7, 8, 9]
第4次
[6, 5, 7, 8, 9]

【第4趟】
第1次
[5, 6, 7, 8, 9]
第2次
[5, 6, 7, 8, 9]
第3次
[5, 6, 7, 8, 9]
第4次
[5, 6, 7, 8, 9]

优化1

问题：

有些元素已经相互交换过，如何优化？减少次数



第一趟：找出最大的数 9
   第一次： 8 9 7 6 5 (9与8交换)
   第二次： 8 7 9 6 5 (9与7交换)
   第三次： 8 7 6 9 5 (9与6交换)
   第四次： 8 7 6 5 9 (9与5交换)
第二趟：找出最大的数 8
   第一次： 7 8 6 5 9 (8与7交换)
   第二次： 7 6 8 5 9 (8与6交换)
   第三次： 7 6 5 8 9 (8与5交换)
   第四次： 7 6 5 8 9 (8与9交换)【已经比较过，可以优化掉】
第三趟：找出最大的数 7
   第一次： 6 7 5 8 9 (7与6交换)
   第二次： 6 5 7 8 9 (7与5交换)
   第三次： 6 5 7 8 9 (7与8交换)【已经比较过，可以优化掉】
   第四次： 6 5 7 8 9 (8与9交换)【已经比较过，可以优化掉】
第四趟：找出最大的数 6
   第一次： 5 6 7 8 9 (6与5交换)
   第二次： 5 6 7 8 9 (6与7交换)【已经比较过，可以优化掉】
   第三次： 5 6 7 8 9 (7与8交换)【已经比较过，可以优化掉】
   第四次： 5 6 7 8 9 (8与9交换)【已经比较过，可以优化掉】

BubbleSort04.java

package com.matrix.sort.bubble;

import java.util.Arrays;

/**
 * 冒泡排序
 * 
 * BubbleSort1<BR>
 * 创建人:Matrix <BR>
 * 时间：2016年2月28日-下午5:35:46 <BR>
 * 
 * @version 1.0.0
 *
 */
public class BubbleSort04 {

    public static void main(String[] args) {
        int[] arr = { 9, 8, 7, 6, 5 };
        sort(arr);
    }

    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.println("【第" + (i + 1) + "趟】");
            for (int j = 0; j < arr.length - 1 - i; j++) {
                System.out.println("第" + (j + 1) + "次");
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
                System.out.println(Arrays.toString(arr));
            }
            System.out.println("");
        }
    }

}

运行结果：

【第1趟】
第1次
[8, 9, 7, 6, 5]
第2次
[8, 7, 9, 6, 5]
第3次
[8, 7, 6, 9, 5]
第4次
[8, 7, 6, 5, 9]

【第2趟】
第1次
[7, 8, 6, 5, 9]
第2次
[7, 6, 8, 5, 9]
第3次
[7, 6, 5, 8, 9]

【第3趟】
第1次
[6, 7, 5, 8, 9]
第2次
[6, 5, 7, 8, 9]

【第4趟】
第1次
[5, 6, 7, 8, 9]

优化2：

假设数据已经有序，后者经过某趟后有序，减少趟数

如： 8 1 2 3 4

第一趟：1 2 3 4 8

第二趟：1 2 3 4 8没有交换则停止循环

BubbleSort05.java

package com.matrix.sort.bubble;

import java.util.Arrays;

/**
 * 冒泡排序
 * 
 * BubbleSort05<BR>
 * 创建人:Matrix <BR>
 * 时间：2016年2月28日-下午5:35:46 <BR>
 * 
 * @version 1.0.0
 *
 */
public class BubbleSort05 {

    public static void main(String[] args) {
        int[] arr = { 9, 1, 2, 3, 4 };
        sortFinal(arr);
        // sort2(arr);
    }

    public static void sortFinal(int[] arr) {
        boolean sorted = true;
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.println("【第" + (i + 1) + "趟】");
            sorted = true;// 假定有序
            for (int j = 0; j < arr.length - 1 - i; j++) {
                System.out.println("第" + (j + 1) + "次");
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    // 假定失败
                    sorted = false;
                }
                System.out.println(Arrays.toString(arr));
            }
            System.out.println("");
            if (sorted) {
                break;
            }
        }
    }

    public static void sort2(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.println("【第" + (i + 1) + "趟】");
            for (int j = 0; j < arr.length - 1 - i; j++) {
                System.out.println("第" + (j + 1) + "次");
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
                System.out.println(Arrays.toString(arr));
            }
            System.out.println("");
        }
    }

}

运行结果：

【第1趟】
第1次
[1, 9, 2, 3, 4]
第2次
[1, 2, 9, 3, 4]
第3次
[1, 2, 3, 9, 4]
第4次
[1, 2, 3, 4, 9]

【第2趟】
第1次
[1, 2, 3, 4, 9]
第2次
[1, 2, 3, 4, 9]
第3次
[1, 2, 3, 4, 9]
MatrixSparse
关注
  • 3
    点赞
  • 踩
  • 0
    收藏 更改收藏夹
  • 打赏
    打赏
  • 0
    评论
专栏目录
冒泡排序（超详细）
hcz666的博客
06-11 33万+
1、什么是冒泡排序？ 冒泡排序的英文Bubble Sort，是一种最基础的交换排序。之所以叫做冒泡排序，因为每一个元素都可以像小气泡一样，根据自身大小一点一点向数组的一侧移动。 冒泡排序的原理： 每一趟只能确定将一个数归位。即第一趟只能确定将末位上的数归位，第二趟只能将倒数第 2 位上的数归位，依次类推下去。如果有 n 个数进行排序，只需将 n-1 个数归位，也就是要进行 n-1 趟操作。 而 “每一趟 ” 都需要从第一位开始进行相邻的两个数的比较，将较大的数放后面，比较完毕之后向后挪一位继续比较下面
史上最详细最简单的冒泡排序，一学就会，一看就懂，一面试就懵！
编程界明世隐的博客
01-13 1万+
什么叫冒泡排序 依次比较两个相邻的子元素，如果他们的顺序错误就把他们交换过来，重复地进行此过程直到没有相邻元素需要交换，即完成整个冒泡。 现在设定一个数组，元素为 2,4,3,1 我们需要通过冒泡最终排序成1,2,3,4用图来说明一下: 那首先我们就对第一个元素2和第2个元素4进行比较，如果第一个元素大于第2个元素则交换位置，否则不交换 于是我们编写代码如下 int[] arr = new int[] { 2, 4, 3, 1 }; if(arr[0].
C语言——冒泡排序
热门推荐
记录学习点滴
03-13 21万+
冒泡排序的原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。 以从小到大排序为例，第一轮比较后，所有数中最大的那个数就会浮到最右边；第二轮比较后，所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较，最后实现从小到大排序。 代码如下 #include<stdio.h> void BBsort(int arr[], int size) { int j,i,tem; for (i = 0; i ..
排序算法之冒泡排序（图解）
Sueko的博客
05-03 1万+
排序算法之冒泡排序（图解）
C语言排序算法（一）：冒泡排序
sunshine的博客
01-31 1万+
分享一下我对C语言中冒泡排序算法的学习和理解（裂开了，足足写了一天，自闭中…） 冒泡排序 冒泡排序（英语：Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们的位置交换过来。走访数列重复地进行直到排序完成。因为越大（小）的元素经过交换会慢慢"浮"到数列的顶端（尾端），就如同碳酸饮料中的气泡一样，故名“冒泡排序”。 算法原理 以从大到小降序排列为例。 第一轮走访开始 ----> 比较相邻的元素- —> 如果第一个元素比第二个元素
交换排序算法之冒泡排序-C语言版（带图详细）
小陈没烦恼
04-02 4259
相信大家在学习数据结构算法的时候经常会遇到的问题就是，老师讲解完这个算法思想，自己也听懂了，但一到自己写代码就写不出来，或者是即便自己模模糊糊的照着网上的代码自己写出来了，但是过几天就又忘了，其实这就是我们没有深刻的理解的这个算法的思想。 接下来，我就结合图例给大家详细的讲解一下。
漫画：什么是冒泡排序？
CSDN资讯
07-23 5281
————— 当天上午 —————什么是冒泡排序？冒泡排序的英文Bubble Sort，是一种最基础的交换排序。大家一定都喝过汽水，汽水中常常有许多小小的气泡，哗啦哗啦...
冒泡排序详解
最新发布
weixin_42571338的博客
08-27 9629
冒泡排序详解
冒泡排序算法
qq_44111805的博客
01-31 4万+
一、冒泡排序算法基本思想 将第一个元素和第二个元素进行比较，若为逆序则将两个元素交换，然后比较第二个元素和第三个元素。依次类推，直至第 n-1个元素和第 n个元素进行比较为止。上述过程称为第一趟冒泡排序，其结果使最大值元素被放置在最后一个位置（第 n个位置）。然后进行第二趟冒泡排序，对前 n-1个元素进行同样操作，其结果是使第二大元素被放置在倒数第二个位置上（第 n-1个位置）。 二、冒泡排序图解 黄色表示已排序部分，蓝色表示未排序部分。 三、代码实现 package Sort; import java
冒泡排序法(Bubble Sort)
lanleihhh的博客
03-29 993
冒泡排序法Bubble Sort一、冒泡排序基本思想二、冒泡排序步骤三、动图演示正序最快,倒序最慢(可倒序循环)四、代码示例总结 文章目录一、冒泡排序基本思想二、冒泡排序步骤三、动图演示正序最快,倒序最慢(可倒序循环)四、代码示例总结 一、冒泡排序基本思想 两两比较相邻记录的元素，如果反序则交换，直到没有反序的记录为止。 二、冒泡排序步骤 1.从第一个元素开始,比较相邻的元素。如果第一个比第二个大，就交换他们两个的位置 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后(第一次循环
冒泡排序法（超详细）
m0_53558236的博客
08-18 2万+
冒泡排序法 文章目录冒泡法的基本思路思路总结程序实现 下面我们一起来看看排序中的冒泡排序法。 ????[例]有5个数字，要求对它们按由小到大的顺序排列。 这种问题称为数的排序(sort)。排序的规律有两种:一种是“升序”，从小到大;另一种是“降序”，从大到小。可以把这个题目抽象为一般形式“对n个数按升序排序”。 排序方法是一种重要的、基本的算法。排序的方法很多,这道题我们用冒泡法排序。 冒泡法的基本思路 冒泡法的基本思路是:每次将相邻两个数比较,将小的调到前面。若有5个数: 9,8,5,2,0,第1次先将最
C语言实现冒泡排序
wantsnowfly的博客
01-15 5万+
冒泡排序作为学习排序最基本的算法，具有稳定性与实用性。 下面是C语言冒泡排序的源代码 #include<stdio.h> int main(void) { int a[10]={6,4,3,2,7,8,9,10,1,5}; int i,k,w; for(i=0;i<9;i++) { for(k=0;k<9-i;k++) { if(a[k]>a[k+1]) { ...
排序算法之冒泡排序
rain67的博客
02-20 6056
文章目录1.冒泡排序2.冒泡排序的思想3.c语言实现代码 1.冒泡排序 对arr数组的元素进行升序排序   给定一个数组 int arr[]={10,9,8,7,6,5,4,3,2,1}； 如何进行排序呢？ 2.冒泡排序的思想      两两相邻元素进行比较，数值大的元素排到后面。 一趟冒泡排序： 如果第一个元素比第二个元素大，那么两两进行交换，重复此过程。 arr[j]如果大于arr[j+1],那么两两进行交换，重复至不能交换。 int j = 0; for (j = 0;
冒泡排序（详解）
weixin_45796387的博客
12-12 1万+
冒泡排序 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单基础的排序算法。其基本思路是，对于一组要排序的元素列，依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面，如此继续，直到比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成。 这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 冒泡排序算法的原理如下： 假设一共有M个元素需要排序，比较相邻
冒泡排序C语言
qq_44021201的博客
10-07 2809
冒泡排序 N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数 #define _CRT_SECURE_NO_WARNINGS 1 //预编时处理一下,加个宏而已,让其忽略安全检测 #include <stdio.h> int main() { int sort[6]; int temp, i, j; //i是数组下标，j是比较次数 printf("请输入6个数字:\n"); f
echarts中堆叠柱状图的排序问题
xixisi888的博客
09-15 1万+
有时候我们要对eharts的 柱形图的堆叠图 进行排序，例如属性排序 名字排序、分数排序等。 echarts 没有排序的方法可用。但是我们可以通过对metrics的series数组进行排序，这样我们可以实现柱状图排序的功能。 现将数据封装为一个集合，可根据集合的某个属性进行排序，排序完成后在push进去 series里，这样得到的效果结束排序后的柱状图的排序堆叠图。 // vehicleAbnormal.sort((a, b) => { return b.name.local
C语言冒泡排序
小S的博客
04-29 2万+
冒泡排序？不难，这篇就够了！ for(int i=0;i
冒泡排序 (三种方法)
a214704的博客
08-02 9521
 冒泡排序              方法一：每趟从第一个元素开始，依次与下一个元素比较，大的往下交换;          方法二：记录交换位置，可以省略下趟不必要的比较（如果后面几个元素已经是有序的，第二趟就直接不用比较这几个元素）;          方法三：双向冒泡，正向找最大(从最小元素交换位置处开始比较，找到最大元素并记录交换位置)，反向找最小(从最大元素交换位置处开始比较，找到最...
排序（一）冒泡排序法
Iseno_V的博客
06-16 5万+
冒泡排序法 稳定性： 稳定 所谓排序算法的稳定性，指当原始数据中存在多个相同的值时，在排序后这些值的相对位置不变。 时间复杂度： O(n2) 空间复杂度： O(1) 冒泡排序算法过程并不包括原始数据的存储过程，所以空间复杂度是 O(1)而不是O(n)。 算法详解 以从小到大排序为例，冒泡排序法的思路是： 遍历原始数据，从第一个数开始，到倒数第二个数结束，比较这个数和下一个数的大小，如果这个数比下一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MatrixSparse

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额：-- )
扫码支付
扫码支付：¥2
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、C币套餐、付费专栏及课程。

余额充值