java常用算法之交换排序---冒泡排序

最新推荐文章于 2024-09-11 22:48:33 发布
最新推荐文章于 2024-09-11 22:48:33 发布
阅读量166 收藏
点赞数 1
分类专栏： 交换排序 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43916023/article/details/105431879
版权

代码块：

public class MaoPao implements SuanFa
{
    private static Logger logger = Logger.getLogger(MaoPao.class);
    @Override
    //方法解析，冒泡的意思就是，
    //第一次把最大的往末端移动
    //第二次把第二大的往末端倒数第二移动，依次类推。
    //相当于把临近两位比较，大的数往后放，然后再拿大的数和后面一位比较大小，最终末尾的将是最大的数。
    public void suanFaRealise(int data[])
    {
        logger.info("maopao realise start.");
        int dataSize = data.length;
        for (int i = 0; i < dataSize - 1; i++)
        {
            logger.debug("1.此时结果为： " + UtilTool.toString(data));
            for (int j = 0; j < dataSize - i - 1; j++)
            {
                if (data[j] > data[j + 1])
                {
                    //交换位置，下一次循环进来data[j]就变成比较大的那个数。
                    int temp = data[j + 1];
                    data[j + 1] = data[j];
                    data[j] = temp;
                    logger.debug("2.此时结果为： " + UtilTool.toString(data));

                }
                else
                {
                    //不交换位置，下次循环进来data[j]就变成较大那个数
                    logger.debug("3.此时结果为： " + UtilTool.toString(data));
                    continue;

                }
            }
        }
    }
}

测试类

public class Test {
    private static Logger logger = Logger.getLogger(Test.class);

    public static void main(String args[])
    {
        int[] test = {6, 1, 22, 7, 9, 33, 98, 55, 23, 78, 48};
        logger.info("maopao test start.");
        SuanFa maopao = SuanFaFactory.getMaoPao();
        maopao.suanFaRealise(test);
        logger.debug(UtilTool.toString(test));
    }
}

执行过程：
[DEBUG] 2020-04-10 13:21:16,713 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:22)
1.此时结果为： [6, 1, 22, 7, 9, 33, 98, 55, 23, 78, 48]
[DEBUG] 2020-04-10 13:21:16,713 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:31)
2.此时结果为： [1, 6, 22, 7, 9, 33, 98, 55, 23, 78, 48]
[DEBUG] 2020-04-10 13:21:16,713 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 22, 7, 9, 33, 98, 55, 23, 78, 48]
[DEBUG] 2020-04-10 13:21:16,715 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:31)
2.此时结果为： [1, 6, 7, 22, 9, 33, 98, 55, 23, 78, 48]
[DEBUG] 2020-04-10 13:21:16,715 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:31)
2.此时结果为： [1, 6, 7, 9, 22, 33, 98, 55, 23, 78, 48]
[DEBUG] 2020-04-10 13:21:16,715 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 33, 98, 55, 23, 78, 48]
[DEBUG] 2020-04-10 13:21:16,715 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 33, 98, 55, 23, 78, 48]
[DEBUG] 2020-04-10 13:21:16,715 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:31)
2.此时结果为： [1, 6, 7, 9, 22, 33, 55, 98, 23, 78, 48]
[DEBUG] 2020-04-10 13:21:16,716 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:31)
2.此时结果为： [1, 6, 7, 9, 22, 33, 55, 23, 98, 78, 48]
[DEBUG] 2020-04-10 13:21:16,716 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:31)
2.此时结果为： [1, 6, 7, 9, 22, 33, 55, 23, 78, 98, 48]
[DEBUG] 2020-04-10 13:21:16,716 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:31)
2.此时结果为： [1, 6, 7, 9, 22, 33, 55, 23, 78, 48, 98]
[DEBUG] 2020-04-10 13:21:16,716 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:22)
1.此时结果为： [1, 6, 7, 9, 22, 33, 55, 23, 78, 48, 98]
[DEBUG] 2020-04-10 13:21:16,716 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 33, 55, 23, 78, 48, 98]
[DEBUG] 2020-04-10 13:21:16,717 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 33, 55, 23, 78, 48, 98]
[DEBUG] 2020-04-10 13:21:16,718 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 33, 55, 23, 78, 48, 98]
[DEBUG] 2020-04-10 13:21:16,718 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 33, 55, 23, 78, 48, 98]
[DEBUG] 2020-04-10 13:21:16,718 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 33, 55, 23, 78, 48, 98]
[DEBUG] 2020-04-10 13:21:16,718 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 33, 55, 23, 78, 48, 98]
[DEBUG] 2020-04-10 13:21:16,718 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:31)
2.此时结果为： [1, 6, 7, 9, 22, 33, 23, 55, 78, 48, 98]
[DEBUG] 2020-04-10 13:21:16,718 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 33, 23, 55, 78, 48, 98]
[DEBUG] 2020-04-10 13:21:16,719 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:31)
2.此时结果为： [1, 6, 7, 9, 22, 33, 23, 55, 48, 78, 98]
[DEBUG] 2020-04-10 13:21:16,720 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:22)
1.此时结果为： [1, 6, 7, 9, 22, 33, 23, 55, 48, 78, 98]
[DEBUG] 2020-04-10 13:21:16,720 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 33, 23, 55, 48, 78, 98]
[DEBUG] 2020-04-10 13:21:16,720 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 33, 23, 55, 48, 78, 98]
[DEBUG] 2020-04-10 13:21:16,721 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 33, 23, 55, 48, 78, 98]
[DEBUG] 2020-04-10 13:21:16,721 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 33, 23, 55, 48, 78, 98]
[DEBUG] 2020-04-10 13:21:16,721 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 33, 23, 55, 48, 78, 98]
[DEBUG] 2020-04-10 13:21:16,721 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:31)
2.此时结果为： [1, 6, 7, 9, 22, 23, 33, 55, 48, 78, 98]
[DEBUG] 2020-04-10 13:21:16,721 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 55, 48, 78, 98]
[DEBUG] 2020-04-10 13:21:16,721 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:31)
2.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,721 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:22)
1.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,721 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,722 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,722 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,722 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,722 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,722 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,722 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,723 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:22)
1.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,723 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,723 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,723 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,723 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,723 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,724 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,724 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:22)
1.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,724 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,724 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,724 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,725 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,725 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,725 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:22)
1.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,725 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,725 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,725 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,726 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,726 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:22)
1.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,726 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,726 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,726 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,726 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:22)
1.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,726 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,726 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,727 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:22)
1.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]
[DEBUG] 2020-04-10 13:21:16,727 method:main.java.suanfa.MaoPao.suanFaRealise(MaoPao.java:37)
3.此时结果为： [1, 6, 7, 9, 22, 23, 33, 48, 55, 78, 98]

重楼大哥
关注
专栏目录
基础：冒泡排序c语言实现
qq_44028021的博客
11-26 230
关于排序算法的经典算法——冒泡排序 冒泡排序具体思想： http://c.biancheng.net/view/192.html 冒泡排序算法，C语言冒泡排序算法详解 冒泡排序的原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。 以从小到大排序为例，第一轮比较后，所有数中最大的那个数就会浮到最右边；第二轮比较后，所有数中第二...
【交换排序算法】【冒泡排序】
珍心
05-31 297
冒泡排序 督促自己学习总结，特用文章的形式记录下来，共同进步
经典排序算法（1）——冒泡排序算法详解
热门推荐
渴望，就奋力追寻...
03-16 14万+
冒泡排序（Bubble Sort）是一种典型的交换排序算法，通过交换数据元素的位置进行排序。 一、算法基本思想 （1）基本思想 冒泡排序的基本思想就是：从无序序列头部开始，进行两两比较，根据大小交换位置，直到最后将最大（小）的数据元素交换到了无序队列的队尾，从而成为有序序列的一部分；下一次继续这个过程，直到所有数据元素都排好序。 算法的核心在于每次通过两两比较交换位置，选出
C语言———冒泡算法
weixin_51871601的博客
07-21 1万+
一：冒泡算法是怎么样去对一堆无序数字进行排序的？ 1.首先我先说明一下冒泡排序的特点：冒泡排序特点就是每一趟排序把最大的数字找出来并且同时放在最后。这样通过有限次的排序后，有限-无序-序列的数字就会被排序成有序序列。 2.那么冒泡算法是如何对数字进行排序的呢？ 概念：以第一个数字为首，与后面第二个数字进行比较，如果第一个数字比第二个数字大，那么就把第一个数字与第二个数字的位置进行交换，否则该数字位置不变。然后第二个数字又与第三个数字进行比较，如果第二个数字大于第三个数字的话，则第二个数字与第三个数字进
冒泡算法详解(AVA)
一张小羊毛的博客
07-06 2601
冒泡算法详解
java常用排序算法——交换排序（冒泡排序和交换排序）
weixin_44782221的博客
07-22 358
2、交换排序 2.1概述 所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。 2.2冒泡排序 2.2.1 排序的基本思想 冒泡排序（Bubble Sort）是一种非常经典的排序算法。名字的来由是因为它的算法思想类似于鱼儿在河里吐泡泡的场景，例如升序排列一列数，它会两两相邻的数据进行比较，...
Java常见排序算法之交换排序
weixin_46429649的博客
05-24 465
public class 交换排序 { public static void swap(int[] array, int i, int j){ int tmp = array[i]; array[i] = array[j]; array[j] = tmp; } /** * 冒泡排序： * 时间复杂度：0(n^2) 逆序情况下 * 有序情况下：0(n) * * 空间复杂度：0(n)
详解Java常用排序算法-冒泡排序
08-26
Java排序算法之冒泡排序详解 冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就交换位置。这个过程持续对数列的末尾进行，直到整个数列都排序完成...
Java后端算法-冒泡排序和选择排序对比
03-17
冒泡排序是一种交换排序，通过不断比较相邻元素并交换位置来实现排序。其基本思想是从数组的一端开始，依次比较相邻的两个元素，如果顺序错误就交换它们的位置。这个过程就像水底下的气泡一样逐渐上浮，因此得名...
详解Java常用排序算法-快速排序
08-26
快速排序算法的时间复杂度为 O(nlogn)，它的性能比冒泡排序和插入排序要好得多，特别是在大型列表上。 快速排序算法的优点： * 高效排序：快速排序算法的时间复杂度为 O(nlogn)，使其在大型列表上的性能优于其他...
java代码-冒泡排序-----
07-14
冒泡排序是一种基础的排序算法，它通过重复遍历待排序的序列，比较相邻元素并交换位置，使得每个元素都能逐步“浮”到正确的位置上。这个过程就像水中的气泡一样，较大的元素逐渐上升到顶部。在Java编程中，我们可以...
Java算法-冒泡排序
01-21
　冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，...
冒泡排序就这么简单
weixin_34161064的博客
03-17 319
冒泡排序就这么简单 在我大一的时候自学c语言和数据结构，我当时就接触到了冒泡排序(当时使用的是C语言编写的)。现在大三了，想要在暑假找到一份实习的工作，又要回顾一下数据结构与算法的知识点了。 排序对我们来说是一点也不陌生了，当你打王者荣耀的时候也会有段位之分，当你打Dota的时候也有天梯分。从高往下数，这个排名是有规律的，就是一种排序。 我最开始接触的就是冒泡排序，所以这篇博文主要讲的是冒泡排序。...
maopao算法及其分析
lovekobe1997的博客
10-17 557
冒泡算法 package mytext; public class maopao { public static void main(String[] args) { int a[]= {12,312,3,1,23,124,53,6,7,53};//创建一个整形数组 for(int i=1;i<a.length;i++) { //这一行说明一共要循坏多少圈 for(int j=0;j<a.length-i;j++) {//每一圈循环的次数 if(a[j]>...
经典算法之冒泡算法
zhangxing
11-20 2713
前言 冒泡算法是一种经典的排序算法，在大学起初学习C语言的时候，冒泡算法是笔者接触编程的第一个算法。冒泡，顾名思义就是轻(小)的往上冒，重(大)的往下沉，也称鸡尾酒算法。 算法解析 首先我们需要确立两层嵌套for循环，第一层for循环主要控制总体循环的趟数，第二层for循环主要是比对相邻的两个数，运用CAS的思路将每一趟的第二层for循环执行完成，就会将一个最大的数沉到最下面。来张图，理解效果会更佳！ 算法实战 public class BubbleSort { public static
冒泡算法和递归算法
云海的博客
02-18 1391
冒泡算法是java中用来排序的算法，冒泡算法会改变原数据中数据的位置， 并不是仅仅排序，看清需求在决定用不用冒泡。 以一串数组为例，冒泡算法依据两个for循环嵌套，逐次比较，互换位置，直到位置不在改变时停止。 代码实现如下 int[] num={1,8,4,3,6,7,5}; public static void main(String args[]){ Test...
JS-算法：冒泡排序
chushu4289的博客
10-15 938
算法基本思想： 1、比较相邻的元素。如果第一个比第二个大（小），就交换他们两个。 2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大（小）的数。 3、针对所有的元素重复以上的步骤，除了最后已经选出的元素（有序）。 4、持续每次对越来越少的元...
排序算法（2）冒泡排序
weixin_44033440的博客
09-24 3759
冒泡排序分从大到小和从小到大两种排序方式。它们的唯一区别就是两个数交换的条件不同，从大到小排序是前面的数比后面的小的时候交换，而从小到大排序是前面的数比后面的数大的时候交换。我这里只说 从小到大的排序方式。 冒泡排序的原理：从第一个数开始，依次往后比较，如果前面的数比后面的数大就交换，否则不作处理。这就类似烧开水时，壶底的水泡往上冒的过程。 一、 图解分析 现以数组[8,7,6,4,5]为...
Java数据结构（十）——冒泡排序、快速排序
最新发布
xiaokuer_的博客
09-11 1067
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
Java冒泡排序算法详解-GridControl使用技巧
"冒泡排序算法在Java中的实现以及在devexpress的gridcontrol中的应用技巧" 冒泡排序是一种基础且简单的排序算法，它通过重复遍历待排序的数列，依次比较相邻元素并根据需要交换位置，使较大的元素逐渐“浮”到数列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值