冒泡排序的优化、代码的复用、面向对象练习

冒泡排序，顾名思义，假设瓶子垂直分布了很多气泡，

最下面的气泡往上浮，在浮动的过程中，如果有气泡比他要小，那就打交换位置

此时，瓶子最上面是最大的气泡

接下来，继续看最下面，原来的气泡已经离开了，那就找它的上面一个

继续往上浮动对比

...

一直重复，直到轮到最下面的

结束

动图你值得拥有：https://www.cnblogs.com/onepixel/articles/7674659.html

package Sort;

import java.util.Random;

public class BubbleSort {
    public static void main(String[] args) {
        int list[]=new int[100];
        Random random=new Random();
//赋值随机数
        for (int i = 0; i < 100; i++) {
            list[i]=random.nextInt(100);
        }
        
        int temp;
//由小到大，冒泡排序
        for (int i = 0; i < list.length; i++) {
            for (int j = 0; j < list.length-i-1; j++) {
                if(list[j]>list[j+1]){
                    temp=list[j];
                    list[j]=list[j+1];
                    list[j+1]=temp;
                }
            }
        }
        
// 输出看一看
        for (int i = 0; i < 100; i++) {
            System.out.println(list[i]);
        }

    }
}

 

接下来开始优化：

优化的方法有很多，咱就实现这哥们的想法吧，总结就是两个思路

• A：某一趟排序，发现一个位置都没变，那就说明已经排好了，就不用继续排序了
• B：某一趟排序，发现从位置x之后，就没变过位置，那下一轮就比到位置x就可以了

那就开始优化A

package Sort;

import java.util.Random;

public class BubbleSort02 {
    public static void main(String[] args) {
        int list[]=new int[100];
        Random random=new Random();
        for (int i = 0; i < 100; i++) {
            list[i]=random.nextInt(100);
        }
        int temp;
        boolean flag=false;//设立flag
        
//由小到大，冒泡排序
        for (int i = 0; i < list.length; i++) {
            for (int j = 0; j < list.length-i-1; j++) {
                if(list[j]>list[j+1]){
                    temp=list[j];
                    list[j]=list[j+1];
                    list[j+1]=temp;
                    flag=true; //如果发生数据交换，flag变化
                }
            }
            if(flag==false) break;
        }

// 输出看一看
        for (int i = 0; i < 100; i++) {
            System.out.println(list[i]);
        }

    }
}

接着，优化B

 

package Sort;

import java.util.Random;

public class BubbleSort03 {
    public static void main(String[] args) {
        int list[]=new int[100];
        Random random=new Random();
        for (int i = 0; i < 100; i++) {
            list[i]=random.nextInt(100);
        }
        int temp;
        int lastlength=list.length-1;
        int lastlengthtemp=list.length-1;//temp
        boolean flag=false;//设立flag

//由小到大，冒泡排序
        for (int i = 0; i < list.length; i++) {
            for (int j = 0; j < lastlength; j++) {
                if(list[j]>list[j+1]){
                    temp=list[j];
                    list[j]=list[j+1];
                    list[j+1]=temp;
                    lastlengthtemp=j;//必须要用临时变量
                    flag=true; //如果发生数据交换，flag变化
                }
            }
            lastlength=lastlengthtemp;
            if(flag==false) break;
        }

// 输出看一看
        for (int i = 0; i < 100; i++) {
            System.out.println(list[i]);
        }

    }
}

 

实现代码复用，面向对象的复习

具体的更新就放在码云吧：https://gitee.com/yaoyibin0627/Sort

第一版：简单工厂模式，但是输出结果可以证明冒泡排序确实得到了优化

 

第二版：高内聚了。开闭原则：对拓展开放，对修改关闭

第三版：将尝试使用继承