排序算法-冒泡排序（工具类）

已于 2023-04-26 14:07:23 修改
阅读量633 收藏 2
点赞数 3
分类专栏： 算法 数组 文章标签： 排序算法 算法 java
于 2022-10-31 19:16:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44715376/article/details/127621389
版权

冒泡排序

什么是冒泡排序

冒泡排序（Bubble Sort），是计算机科学领域简单的排序算法

重复的访问每一个元素，依次相邻的两个元素进行比较大小，进行交换位置，

为什么叫冒泡排序：

  • 越小的元素会经过交换位置来浮到数组的顶端，（升序或降序的排序），类似水中气泡慢慢浮现到水面

原理

冒泡排序的原理是通过比较相邻的元素，将较大的元素交换到右侧，较小的元素交换到左侧，从而实现排序的目的。

具体实现是通过嵌套两个循环，外层循环控制排序趟数，内层循环控制每一趟排序多少次。

在每一趟排序中，如果前一个数比后一个数大，则交换两个数的位置。

升序

@Test
public void testBubbling() {
    int[] a = {1, 47, 4, 36, 8, 2, 90, 2, 3};
    //将数组长度赋值给变量，（在for循环中每次计算数组长度）
    int aLength = a.length;
    System.out.println("未排序前的数组"+Arrays.toString(a));

    //排序次数
    for (int i = 1; i < aLength; i++) {
        //循环索引
        for (int j = 0; j < aLength - i; j++) {
            //比较大小
            if (a[j] > a[j + 1]) {
                //调换位置
                int stemp = a[j]; //大值赋值给变量
                a[j] = a[j + 1];//小值往前赋值
                a[j + 1] = stemp;//变量值向当前索引赋值
            }
        }
    }
    System.out.println("排序后的结果"+Arrays.toString(a));
}

运行结果

在这里插入图片描述

分析

  • 依次对相邻两个元素做比较
    在这里插入图片描述

降序

@Test
public void testBubbling() {
    int[] a = {1, 47, 4, 36, 8, 2, 90, 2, 3};
    //将数组长度赋值给变量，（在for循环中每次计算数组长度）
    int aLength = a.length;
    System.out.println("未排序前的数组"+Arrays.toString(a));

    //排序次数
    for (int i = 1; i < aLength; i++) {
        //循环索引
        for (int j = 0; j < aLength - i; j++) {
            //比较大小
            if (a[j] < a[j + 1]) {
                //调换位置
                int stemp = a[j+1]; //大值赋值给变量
                a[j+1] = a[j];//小值往后赋值
                a[j] = stemp;//变量值向当前索引赋值
            }
        }
    }
    System.out.println("排序后的结果"+Arrays.toString(a));
}

运行结果

在这里插入图片描述

冒泡排序工具类

方法返回类型作用参数说明访问权限
ascengSort(byte[] a)byte[]对byte数组升序排序传入byte数组公开
ascengSort(byte[] a，int fromIndex,int toIndex)byte[]对byte数组具体索引升序排序传入byte数组,开始索引，结束索引公开
ascengSort(short[] a)short[]对short数组升序排序传入short数组公开
ascengSort(short[] a,int fromIndex,int toIndex)short[]对short数组具体索引升序排序传入short数组,开始索引，结束索引公开
ascengSort(int[] a)int[]对int数组升序排序传入int数组公开
ascengSort(int[] a,int fromIndex,int toIndex)int[]对int数组具体索引升序排序传入int数组,开始索引，结束索引公开
ascengSort(long[] a)long[]对long数组升序排序传入long数组公开
ascengSort(long[] a,int fromIndex,int toIndex)long[]对long数组具体索引升序排序传入long数组,开始索引，结束索引公开
ascengSort(double[] a)double[]对double数组升序排序传入double数组公开
ascengSort(double[] a,int fromIndex,int toIndex)double[]对double数具体索引升序排序传入double数组,开始索引，结束索引公开
ascengSort(float[] a)float[]对float数组升序排序传入float数组公开
ascengSort(float[] a,int fromIndex,int toIndex)float[]对float数组具体索引升序排序传入float数组,开始索引，结束索引公开
ascengSort(char[] a)char[]对char数组升序排序传入char数组公开
ascengSort(char[] a,int fromIndex,int toIndex)char[]对char数组具体索引升序排序传入char数组,开始索引，结束索引公开
dropSort(byte[] a)byte[]对byte数组降序排序传入byte数组公开
dropSort(byte[] a, int fromIndex, int toIndex)byte[]对byte数组具体索引降序排序传入byte数组,开始索引，结束索引公开
dropSort(short[] a)short[]对short数组降序排序传入short数组公开
dropSort(short[] a, int fromIndex, int toIndex)short[]对short数组具体索引降序排序传入short数组,开始索引，结束索引公开
dropSort(int[] a)int[]对int数组降序排序传入int数组公开
dropSort(int[] a, int fromIndex, int toIndex)int[]对int数组具体索引降序排序传入int数组,开始索引，结束索引公开
dropSort(long[] a)long[]对long数组降序排序传入long数组公开
dropSort(long[] a, int fromIndex, int toIndex)long[]对long数组具体索引降序排序传入long数组,开始索引，结束索引公开
dropSort(double[] a)double[]对double数组降序排序传入double数组公开
dropSort(double[] a, int fromIndex, int toIndex)double[]对double数组具体索引降序排序传入double数组,开始索引，结束索引公开
dropSort(float[] a)float[]对float数组降序排序传入float数组公开
dropSort(float[] a, int fromIndex, int toIndex)float[]对float数组具体索引降序排序传入float数组,开始索引，结束索引公开
dropSort(char[] a)char[]对char数组降序排序传入char数组公开
dropSort(char[] a, int fromIndex, int toIndex)char[]对char数组具体索引降序排序传入char数组,开始索引，结束索引公开
rangeCheck(int arrayLength, int fromIndex, int toIndex)void索引范围比较数组长度，开始索引，结束索引私有
package com.sin.demo.utli;

/**
 * @author sin
 * @date 2022/10/31
 * @apiNote
 */
public class BubbleSortUtlis {


    /**
     * 升序排序
     *
     * @param a 传入的数组
     * @return
     */
    public byte[] ascengSort(byte[] a) {
        int aLength = a.length;
        int i, j;
        for (i = 1; i < aLength; i++) {
            for (j = 0; j < aLength - 1; j++) {
                if (a[j] > a[j + 1]) {
                    byte cache = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 升序排序
     *
     * @param a         传入的数组
     * @param fromIndex 开始元素
     * @param toIndex   结束元素
     * @return
     */
    public byte[] ascengSort(byte[] a, int fromIndex, int toIndex) {
        int aLength = a.length;
        //对索引范围的校验
        this.rangeCheck(aLength, fromIndex, toIndex);

        int cycles = fromIndex - toIndex;

        int i, j;
        for (i = cycles; i < aLength; i++) {
            for (j = fromIndex; j < toIndex; j++) {
                if (a[j] > a[j + 1]) {
                    byte cache = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 升序排序
     *
     * @param a 传入的数组
     * @return
     */
    public short[] ascengSort(short[] a) {
        int aLength = a.length;
        int i, j;
        for (i = 1; i < aLength; i++) {
            for (j = 0; j < aLength - 1; j++) {
                if (a[j] > a[j + 1]) {
                    short cache = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 升序排序
     *
     * @param a         传入的数组
     * @param fromIndex 开始元素
     * @param toIndex   结束元素
     * @return
     */
    public short[] ascengSort(short[] a, int fromIndex, int toIndex) {
        int aLength = a.length;
        //对索引范围的校验
        this.rangeCheck(aLength, fromIndex, toIndex);

        int cycles = fromIndex - toIndex;

        int i, j;
        for (i = cycles; i < aLength; i++) {
            for (j = fromIndex; j < toIndex; j++) {
                if (a[j] > a[j + 1]) {
                    short cache = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 升序排序
     *
     * @param a 传入的数组
     * @return
     */
    public int[] ascengSort(int[] a) {
        int aLength = a.length;
        int i, j;
        for (i = 1; i < aLength; i++) {
            for (j = 0; j < aLength - 1; j++) {
                if (a[j] > a[j + 1]) {
                    int cache = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = cache;
                }
            }
        }
        return a;
    }


    /**
     * 升序排序
     *
     * @param a         传入的数组
     * @param fromIndex 开始元素
     * @param toIndex   结束元素
     * @return
     */
    public int[] ascengSort(int[] a, int fromIndex, int toIndex) {
        int aLength = a.length;
        //对索引范围的校验
        this.rangeCheck(aLength, fromIndex, toIndex);

        int cycles = fromIndex - toIndex;

        int i, j;
        for (i = cycles; i < aLength; i++) {
            for (j = fromIndex; j < toIndex; j++) {
                if (a[j] > a[j + 1]) {
                    int cache = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 升序排序
     *
     * @param a 传入的数组
     * @return
     */
    public long[] ascengSort(long[] a) {
        int aLength = a.length;
        int i, j;
        for (i = 1; i < aLength; i++) {
            for (j = 0; j < aLength - 1; j++) {
                if (a[j] > a[j + 1]) {
                    long cache = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 升序排序
     *
     * @param a         传入的数组
     * @param fromIndex 开始元素
     * @param toIndex   结束元素
     * @return
     */
    public long[] ascengSort(long[] a, int fromIndex, int toIndex) {
        int aLength = a.length;
        //对索引范围的校验
        this.rangeCheck(aLength, fromIndex, toIndex);

        int cycles = fromIndex - toIndex;

        int i, j;
        for (i = cycles; i < aLength; i++) {
            for (j = fromIndex; j < toIndex; j++) {
                if (a[j] > a[j + 1]) {
                    long cache = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 升序排序
     *
     * @param a 传入的数组
     * @return
     */
    public double[] ascengSort(double[] a) {
        int aLength = a.length;
        int i, j;
        for (i = 1; i < aLength; i++) {
            for (j = 0; j < aLength - 1; j++) {
                if (a[j] > a[j + 1]) {
                    double cache = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 升序排序
     *
     * @param a         传入的数组
     * @param fromIndex 开始元素
     * @param toIndex   结束元素
     * @return
     */
    public double[] ascengSort(double[] a, int fromIndex, int toIndex) {
        int aLength = a.length;
        //对索引范围的校验
        this.rangeCheck(aLength, fromIndex, toIndex);

        int cycles = fromIndex - toIndex;

        int i, j;
        for (i = cycles; i < aLength; i++) {
            for (j = fromIndex; j < toIndex; j++) {
                if (a[j] > a[j + 1]) {
                    double cache = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 升序排序
     *
     * @param a 传入的数组
     * @return
     */
    public float[] ascengSort(float[] a) {
        int aLength = a.length;
        int i, j;
        for (i = 1; i < aLength; i++) {
            for (j = 0; j < aLength - 1; j++) {
                if (a[j] > a[j + 1]) {
                    float cache = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 升序排序
     *
     * @param a         传入的数组
     * @param fromIndex 开始元素
     * @param toIndex   结束元素
     * @return
     */
    public float[] ascengSort(float[] a, int fromIndex, int toIndex) {
        int aLength = a.length;
        //对索引范围的校验
        this.rangeCheck(aLength, fromIndex, toIndex);

        int cycles = fromIndex - toIndex;

        int i, j;
        for (i = cycles; i < aLength; i++) {
            for (j = fromIndex; j < toIndex; j++) {
                if (a[j] > a[j + 1]) {
                    float cache = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = cache;
                }
            }
        }
        return a;
    }
    /**
     * 升序排序
     *
     * @param a 传入的数组
     * @return
     */
    public char[] ascengSort(char[] a) {
        int aLength = a.length;
        int i, j;
        for (i = 1; i < aLength; i++) {
            for (j = 0; j < aLength - 1; j++) {
                if (a[j] > a[j + 1]) {
                    char cache = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 升序排序
     *
     * @param a         传入的数组
     * @param fromIndex 开始元素
     * @param toIndex   结束元素
     * @return
     */
    public char[] ascengSort(char[] a, int fromIndex, int toIndex) {
        int aLength = a.length;
        //对索引范围的校验
        this.rangeCheck(aLength, fromIndex, toIndex);

        int cycles = fromIndex - toIndex;

        int i, j;
        for (i = cycles; i < aLength; i++) {
            for (j = fromIndex; j < toIndex; j++) {
                if (a[j] > a[j + 1]) {
                    char cache = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = cache;
                }
            }
        }
        return a;
    }


    /**
     * 降序排序
     *
     * @param a 传入的数组
     * @return
     */
    public byte[] dropSort(byte[] a) {
        int aLength = a.length;
        int i, j;
        for (i = 1; i < aLength; i++) {
            for (j = 0; j < aLength - 1; j++) {
                if (a[j] < a[j + 1]) {
                    byte cache = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 降序排序
     *
     * @param a         传入的数组
     * @param fromIndex 开始元素
     * @param toIndex   结束元素
     * @return
     */
    public byte[] dropSort(byte[] a, int fromIndex, int toIndex) {
        int aLength = a.length;
        //对索引范围的校验
        this.rangeCheck(aLength, fromIndex, toIndex);

        int cycles = fromIndex - toIndex;

        int i, j;
        for (i = cycles; i < aLength; i++) {
            for (j = fromIndex; j < toIndex; j++) {
                if (a[j] < a[j + 1]) {
                    byte cache = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 降序排序
     *
     * @param a 传入的数组
     * @return
     */
    public short[] dropSort(short[] a) {
        int aLength = a.length;
        int i, j;
        for (i = 1; i < aLength; i++) {
            for (j = 0; j < aLength - 1; j++) {
                if (a[j] < a[j + 1]) {
                    short cache = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = cache;
                }
            }
        }
        return a;
    }
    /**
     * 降序排序
     *
     * @param a         传入的数组
     * @param fromIndex 开始元素
     * @param toIndex   结束元素
     * @return
     */
    public short[] dropSort(short[] a, int fromIndex, int toIndex) {
        int aLength = a.length;
        //对索引范围的校验
        this.rangeCheck(aLength, fromIndex, toIndex);

        int cycles = fromIndex - toIndex;

        int i, j;
        for (i = cycles; i < aLength; i++) {
            for (j = fromIndex; j < toIndex; j++) {
                if (a[j] < a[j + 1]) {
                    short cache = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 降序排序
     *
     * @param a 传入的数组
     * @return
     */
    public int[] dropSort(int[] a) {
        int aLength = a.length;
        int i, j;
        for (i = 1; i < aLength; i++) {
            for (j = 0; j < aLength - 1; j++) {
                if (a[j] < a[j + 1]) {
                    int cache = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = cache;
                }
            }
        }
        return a;
    }
    /**
     * 降序排序
     *
     * @param a         传入的数组
     * @param fromIndex 开始元素
     * @param toIndex   结束元素
     * @return
     */
    public int[] dropSort(int[] a, int fromIndex, int toIndex) {
        int aLength = a.length;
        //对索引范围的校验
        this.rangeCheck(aLength, fromIndex, toIndex);

        int cycles = fromIndex - toIndex;

        int i, j;
        for (i = cycles; i < aLength; i++) {
            for (j = fromIndex; j < toIndex; j++) {
                if (a[j] < a[j + 1]) {
                    int cache = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 降序排序
     *
     * @param a 传入的数组
     * @return
     */
    public long[] dropSort(long[] a) {
        int aLength = a.length;
        int i, j;
        for (i = 1; i < aLength; i++) {
            for (j = 0; j < aLength - 1; j++) {
                if (a[j] < a[j + 1]) {
                    long cache = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = cache;
                }
            }
        }
        return a;
    }
    /**
     * 降序排序
     *
     * @param a         传入的数组
     * @param fromIndex 开始元素
     * @param toIndex   结束元素
     * @return
     */
    public long[] dropSort(long[] a, int fromIndex, int toIndex) {
        int aLength = a.length;
        //对索引范围的校验
        this.rangeCheck(aLength, fromIndex, toIndex);

        int cycles = fromIndex - toIndex;

        int i, j;
        for (i = cycles; i < aLength; i++) {
            for (j = fromIndex; j < toIndex; j++) {
                if (a[j] < a[j + 1]) {
                    long cache = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = cache;
                }
            }
        }
        return a;
    }


    /**
     * 降序排序
     *
     * @param a 传入的数组
     * @return
     */
    public double[] dropSort(double[] a) {
        int aLength = a.length;
        int i, j;
        for (i = 1; i < aLength; i++) {
            for (j = 0; j < aLength - 1; j++) {
                if (a[j] < a[j + 1]) {
                    double cache = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = cache;
                }
            }
        }
        return a;
    }
    /**
     * 降序排序
     *
     * @param a         传入的数组
     * @param fromIndex 开始元素
     * @param toIndex   结束元素
     * @return
     */
    public double[] dropSort(double[] a, int fromIndex, int toIndex) {
        int aLength = a.length;
        //对索引范围的校验
        this.rangeCheck(aLength, fromIndex, toIndex);

        int cycles = fromIndex - toIndex;

        int i, j;
        for (i = cycles; i < aLength; i++) {
            for (j = fromIndex; j < toIndex; j++) {
                if (a[j] < a[j + 1]) {
                    double cache = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = cache;
                }
            }
        }
        return a;
    }



    /**
     * 降序排序
     *
     * @param a 传入的数组
     * @return
     */
    public float[] dropSort(float[] a) {
        int aLength = a.length;
        int i, j;
        for (i = 1; i < aLength; i++) {
            for (j = 0; j < aLength - 1; j++) {
                if (a[j] < a[j + 1]) {
                    float cache = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = cache;
                }
            }
        }
        return a;
    }
    /**
     * 降序排序
     *
     * @param a         传入的数组
     * @param fromIndex 开始元素
     * @param toIndex   结束元素
     * @return
     */
    public float[] dropSort(float[] a, int fromIndex, int toIndex) {
        int aLength = a.length;
        //对索引范围的校验
        this.rangeCheck(aLength, fromIndex, toIndex);

        int cycles = fromIndex - toIndex;

        int i, j;
        for (i = cycles; i < aLength; i++) {
            for (j = fromIndex; j < toIndex; j++) {
                if (a[j] < a[j + 1]) {
                    float cache = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = cache;
                }
            }
        }
        return a;
    }


    /**
     * 降序排序
     *
     * @param a 传入的数组
     * @return
     */
    public char[] dropSort(char[] a) {
        int aLength = a.length;
        int i, j;
        for (i = 1; i < aLength; i++) {
            for (j = 0; j < aLength - 1; j++) {
                if (a[j] < a[j + 1]) {
                    char cache = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = cache;
                }
            }
        }
        return a;
    }
    /**
     * 降序排序
     *
     * @param a         传入的数组
     * @param fromIndex 开始元素
     * @param toIndex   结束元素
     * @return
     */
    public char[] dropSort(char[] a, int fromIndex, int toIndex) {
        int aLength = a.length;
        //对索引范围的校验
        this.rangeCheck(aLength, fromIndex, toIndex);

        int cycles = fromIndex - toIndex;

        int i, j;
        for (i = cycles; i < aLength; i++) {
            for (j = fromIndex; j < toIndex; j++) {
                if (a[j] < a[j + 1]) {
                    char cache = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = cache;
                }
            }
        }
        return a;
    }

    /**
     * 索引范围比较
     *
     * @param arrayLength 数组长度
     * @param fromIndex   开始索引
     * @param toIndex     结束索引
     */
    private void rangeCheck(int arrayLength, int fromIndex, int toIndex) {
        /**
         * 如果开始索引比结束索引大
         * 则排除非法参数异常
         */
        if (fromIndex > toIndex) {
            throw new IllegalArgumentException(
                    "开始索引(" + fromIndex + ") > 结束索引(" + toIndex + ")");
        }
        /**
         * 如果开始索引小于0
         * 则抛出数组索引越界异常
         */
        if (fromIndex < 0) {
            throw new ArrayIndexOutOfBoundsException(fromIndex);
        }
        /**
         * 如果结束索引小于0
         * 则抛出数组索引越界异常
         */
        if (toIndex > arrayLength) {
            throw new ArrayIndexOutOfBoundsException(toIndex);
        }

    }
}

BubbleSortUtlis工具类测试

//实例化工具类
BubbleSortUtlis bubbleSortUtlis = new BubbleSortUtlis();

int类型数组升序排序

@Test
public void testIntAscengSort() {
    int[] a = {2,5,3,8,1,9,23,11,6};
    System.out.println("排序前"+Arrays.toString(a));
    bubbleSortUtlis.ascengSort(a);
    System.out.println("排序后"+Arrays.toString(a));
}
测试结果

在这里插入图片描述

int类型数组对具体元素升序排序

@Test
public void testIntAscengSort() {
    int[] a = {2,5,3,8,1,9,23,11,6};
    System.out.println("排序前"+Arrays.toString(a));
    bubbleSortUtlis.ascengSort(a,3,7);
    System.out.println("排序后"+Arrays.toString(a));
}
测试结果

在这里插入图片描述

int类型降序排序

@Test
public void testIntAscengSort() {
    int[] a = {2,5,3,8,1,9,23,11,6};
    System.out.println("排序前"+Arrays.toString(a));
    bubbleSortUtlis.dropSort(a);
    System.out.println("排序后"+Arrays.toString(a));
}
测试结果

在这里插入图片描述

int类型对具体元素降序排序

@Test
public void testIntAscengSort() {
    int[] a = {2,5,3,8,1,9,23,11,6};
    System.out.println("排序前"+Arrays.toString(a));
    bubbleSortUtlis.dropSort(a,2,5);
    System.out.println("排序后"+Arrays.toString(a));
}
测试结果

在这里插入图片描述

char类型数组升序排序

 @Test
    public void testCharAscengSort() {
        char[] a = {'a', 'v', 'd', 'e', 'f', 'c', 'b'};
        System.out.println("排序前"+Arrays.toString(a));
        bubbleSortUtlis.ascengSort(a);
        System.out.println("排序后"+Arrays.toString(a));
    }

结束结果
在这里插入图片描述

char类型数组对具体元素升序排序

@Test
public void testCharAscengSort() {
    char[] a = {'a', 'v', 'd', 'e', 'f', 'c', 'b'};
    System.out.println("排序前"+Arrays.toString(a));
    bubbleSortUtlis.ascengSort(a,2,5);
    System.out.println("排序后"+Arrays.toString(a));
}
测试结果

在这里插入图片描述

char类型数组降序排序

@Test
public void testCharAscengSort() {
    char[] a = {'a', 'v', 'd', 'e', 'f', 'c', 'b'};
    System.out.println("排序前"+Arrays.toString(a));
    bubbleSortUtlis.dropSort(a);
    System.out.println("排序后"+Arrays.toString(a));
}
测试结果

在这里插入图片描述

char类型数组对具体元素降序排序

@Test
public void testCharAscengSort() {
    char[] a = {'a', 'v', 'd', 'e', 'f', 'c', 'b'};
    System.out.println("排序前"+Arrays.toString(a));
    bubbleSortUtlis.dropSort(a,2,4);
    System.out.println("排序后"+Arrays.toString(a));
}
测试结果

在这里插入图片描述

陆卿之SIN
关注
专栏目录
java-排序算法总结
02-27
排序算法是用来组织和优化数据结构的关键工具，它可以帮助我们快速查找、分析和处理大量数据。本篇将深入探讨Java中实现的几种主要排序算法，并提供相关的范文、模板和素材。 1. 冒泡排序（Bubble Sort） 冒泡排序...
冒泡排序详解
weixin_42571338的博客
08-27 1万+
冒泡排序详解
冒泡排序详解(Bubble Sort)
Wzill
05-30 1万+
构造的过程就是将无序的序列构造成一个堆的过程。堆的定义是：对于任意一个非叶子节点 i，其左子节点为 2i+1，右子节点为 2i+2，且父节点的值大于等于（或小于等于）其子节点的值。因此，我们可以从最后一个非叶子节点开始，依次将其与其子节点比较，如果不满足堆的定义，则交换位置，直到整个序列构造成一个堆为止。排序的过程就是将堆顶元素与最后一个元素交换位置，然后将剩余元素重新构造成一个堆的过程。每次交换后，堆的大小减一，因此我们可以通过一个变量来记录堆的大小，从而将排序的过程限制在堆的范围内。
数据结构--冒泡排序
最新发布
qq_75238809的博客
07-08 964
【时间复杂度】最好情况当输入数组已经是正序（即从小到大排序）时，只需要进行一次遍历就可以完成，因为在这一次遍历中，我们会发现没有任何一对相邻元素需要交换。然而，即使在这种情况下，我们仍然可以说冒泡排序进行了n-1次比较（其中n是数组的长度）最坏情况当输入数组是逆序（即从大到小排序）时，冒泡排序需要进行n-1趟排序（或称为n-1次遍历），每趟排序都会将当前未排序部分的最大元素移动到其最终位置。在每趟排序中，除了最后一趟可能只进行一次比较外（因为最大的元素已经在它应该在的位置上了），其他每趟都需要进行。
【排序算法】冒泡排序（C语言）
weixin_52811588的博客
07-10 5万+
冒泡排序法是最简单的排序算法之一，这里详述了冒泡排序法的排序原理，以及C语言的代码实现，还有模拟库函数qsort的实现
【经典算法】冒泡排序
yubao0723的专栏
01-10 5356
Java实现经典算法之冒泡排序
冒泡排序（超详细）
热门推荐
hcz666的博客
06-11 38万+
1、什么是冒泡排序？ 冒泡排序的英文Bubble Sort，是一种最基础的交换排序。之所以叫做冒泡排序，因为每一个元素都可以像小气泡一样，根据自身大小一点一点向数组的一侧移动。 冒泡排序的原理： 每一趟只能确定将一个数归位。即第一趟只能确定将末位上的数归位，第二趟只能将倒数第 2 位上的数归位，依次类推下去。如果有 n 个数进行排序，只需将 n-1 个数归位，也就是要进行 n-1 趟操作。 而 “每一趟 ” 都需要从第一位开始进行相邻的两个数的比较，将较大的数放后面，比较完毕之后向后挪一位继续比较下面
Java版的冒泡排序算法
10-11
Java版本的冒泡排序实操代码，编写成了工具类，适用新手学习，可直接调用
算法与数据结构的排序算法
03-15
总结，排序算法是计算机科学中的基础工具，理解和掌握各种排序算法的原理、优缺点以及应用场景，对于提升编程技能和解决实际问题具有重要意义。通过对"排序.c"文件的分析，我们可以更直观地理解这些理论知识，并将其...
基于flutter实现的排序算法原理演示平台设计.zip
03-10
常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等。每种算法都有其独特的优缺点，如时间复杂度、空间复杂度以及稳定性等，这些因素影响着它们在实际应用中的选择。 在Flutter中实现...
控制台显示java冒泡排序流程示例
09-04
Java冒泡排序是一种基础的排序算法，其工作原理是通过重复遍历待排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。...
排序算法之冒泡排序（图解）
Sueko的博客
05-03 4万+
排序算法之冒泡排序（图解）
冒泡排序（详解）
weixin_45796387的博客
12-12 1万+
冒泡排序 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单基础的排序算法。其基本思路是，对于一组要排序的元素列，依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面，如此继续，直到比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成。 这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 冒泡排序算法的原理如下： 假设一共有M个元素需要排序，比较相邻
[ 数据结构 -- 手撕排序算法第二篇 ] 冒泡排序
CSDN博客
04-17 7153
手撕排序算法系列之：冒泡排序。 从本篇文章开始，我会介绍并分析常见的几种排序，大致包括插入排序，冒泡排序，希尔排序，选择排序，堆排序，快速排序，归并排序等。 大家可以点击此链接阅读其他排序算法：排序算法_大合集（data-structure_Sort） 本篇主要来手撕冒泡排序~~ 目录 1.常见的排序算法 1.1交换排序 2.冒泡排序的实现 2.1基本思想 2.2单趟冒泡排序 2.2.1思路分析 2.2.2单趟代码实现 3.冒泡排序代码实现 4.冒泡排序测试 5.冒泡排序..
冒泡排序（超详细图解加代码解析，5分钟看懂）
纪宁的博客
06-02 2万+
冒泡排序算法
排序——冒泡排序
一起加油吧~
02-01 8405
【前言】 小编今天来讲讲VB中的“冒泡排序”！ 【正文】 <**含义**> 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法； 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 <**原理**> 1.大数沉底，小数上...
排序算法：冒泡排序
南雨兮
03-27 1万+
1. 什么是冒泡排序？（摘抄自百度百科） 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 2. 冒泡排序算法原理.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

陆卿之SIN

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

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

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

打赏作者

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

抵扣说明：

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

余额充值