Java实现冒泡排序完整记录（有源码）

最新推荐文章于 2024-09-14 00:06:17 发布

__gy__

最新推荐文章于 2024-09-14 00:06:17 发布

阅读量748

点赞数 3

分类专栏： java中问题与思考文章标签： java 编程语言快速排序算法

本文链接：https://blog.csdn.net/lj317499/article/details/112434760

版权

java中问题与思考专栏收录该内容

9 篇文章 0 订阅

订阅专栏

冒泡排序

编程思想

假设现在要对一组数{3,9,5,6,2,7}做从大到小排序，当然从小到大排序也是一样的，这里只是举例说明其思想。

我们首先要清楚这组数在计算机的存储情况：

这个过程就好比是比武招亲，首先将第一个元素作为最大的元素（擂主），然后依次将后面的元素与这个最大的元素做比较（比武），如果有某一个元素真的比目前假设的元素值要大（比擂主厉害）就将其位置互换（换擂主）。

然后一轮比完了就选出了最大的元素（最强的擂主），这个时候就将最大的元素不考虑，将除去最大元素的剩下的元素再次进行比较。（除去最强的擂主继续比武）

重复执行程序直到最后一个元素为止。（直到最后的一个武士没有对手为止）。

到这里原来的数据就做了重新的排序。

代码


/**
 * @author  LJ
 * @Data 2021/1/10 13:07
 * Java冒泡排序
 */
public class Order {
    
    /**
     * 从小到大排序的方法
     * @param arr  待排序的数据
     * @return  排好序的数据
     */
    public static int[] minToMax(int[] arr){
        for (int i = 0; i < arr.length ; i++) {
            for (int j = i; j < arr.length; j++) {
                if (arr[i]>arr[j]){
                   arr[i]=arr[i]^arr[j];
                   arr[j]=arr[j]^arr[i];
                   arr[i]=arr[i]^arr[j];
                }
            }
        }
        return arr;
    }


    /**
     * 从大到小的排序方法
     * @param arr   待排序的数据
     * @return      排好序的数据
     */
    public static int[] maxToMin(int[] arr){
        for (int i = 0; i < arr.length ; i++) {
            for (int j = i; j < arr.length; j++) {
                if (arr[i]<arr[j]){
                    arr[i]=arr[i]^arr[j];
                    arr[j]=arr[j]^arr[i];
                    arr[i]=arr[i]^arr[j];
                }
            }
        }
        return arr;
    }
}

代码改进 ---将重复的代码进行复用，将交换数据的代码写成一个私有的静态方法


/**
 * @author  LJ
 * @Data 2021/1/10 20:16
 * Java冒泡排序  终极版 
 */
public class Order {

    static int[] arr;
    /**
     * 从小到大排序的方法
     * @param arr  待排序的数据
     * @return  排好序的数据
     */
    public static int[] minToMax(int[] arr){
        Order.arr=arr;
        for (int i = 0; i < arr.length ; i++) {
            for (int j = i; j < arr.length; j++) {
                if (arr[i]>arr[j]){
                    swap(i,j);
                }
            }
        }
        return arr;
    }


    /**
     * 从大到小的排序方法
     * @param arr   待排序的数据
     * @return      排好序的数据
     */
    public static int[] maxToMin(int[] arr){
        Order.arr=arr;
        for (int i = 0; i < arr.length ; i++) {
            for (int j = i; j < arr.length; j++) {
                if (arr[i]<arr[j]){
                    swap(i,j);
                }
            }
        }
        return arr;
    }

    private static void swap(int i,int j){
        arr[i]=arr[i]^arr[j];
        arr[j]=arr[j]^arr[i];
        arr[i]=arr[i]^arr[j];
    }
}

自创代码的测试类：

/**
 * Order class的测试类
 */
public class DuBugOrder {
    public static void main(String[] args) {

        //排序初始化（准备两个数组）
        System.out.println("原数据为：8,4,7,10,17,14,11");
        int[] minMax=Order.minToMax(new int[]{8,4,7,10,17,14,11});
        int[] maxMin=Order.maxToMin(new int[]{8,4,7,10,17,14,11});

        //从小到大排序
        System.out.print("从小到大排序为：");
        for (int i = 0; i < minMax.length; i++) {
            System.out.print(minMax[i]+",");
        }
        System.out.println();

        //从大到小排序
        System.out.print("从大到小排序为：");
        for (int i = 0; i < maxMin.length; i++) {
            System.out.print(maxMin[i]+",");
        }
        System.out.println();
    }
}

测试类的运行截图：

由于改进前后的测试截图都是一样的，所以这里就只放一张了哈(*^▽^*)

总结

虽然这些东西看起来很简单，我在自己动手去做的时候也是这样觉得，但自己去做了才发现会有很多问题出现，然后自己又一步步的DeBug，进一步发现问题，解决问题，扎实基础，努力将根扎的更深，希望在未来面对工作中心中不会那么慌张，毕竟只有丰富的经济基础才能满足上层的爱情需求嘛！！！（愿将来的工作善待我，狗头保命）

言归正传，我在写这个代码的过程中发现的问题：

1、两个交换数据的代码有些重复，想写成一个类，但就发现报错了。

问题原因是静态方法不能调用非静态的方法，但有人会说那竟然要加static那就没必要定义成private的了吧，其实不然，还是应该定义成private。关于这个问题我专门写了一篇文章记录。

2、当第一个问题解决后就为两个数据交换当专门写一个方法（swap方法），但发现在写返回值的时候纠结了，到底是写void还是写int还是写成数组，最终发现写成啥都不成，因为Java语言是极力避免指针的，这里如果是指针还行，很明显java语言是无法实现了！所以不得不重复一些代码了。（好像与Java代码的复用精神背道而驰，狗头保命）刚发现这个问题解决了，就是在源代码（Order.class)的类当中加一个数组引用，其实就是C语言里面的指针，代码如下：