java基本算法复习(一):冒泡排序

闲来无事决定复习一下java相关的基本算法.

冒泡排序:
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名冒泡.

例:
一个无序数组{988,3,12,99,100,33,2,5,66,23,18}; 使用冒泡排序进行排序;
第一次排序:3 | 12 | 99 | 100 | 33 | 2 | 5 | 66 | 23 | 18 | 988 | 此时最大的998被排到最后一位;
第二次排序:3 | 12 | 99 | 33 | 2 | 5 | 66 | 23 | 18 | 100 | 988 |
第三次排序:3 | 12 | 33 | 2 | 5 | 66 | 23 | 18 | 99 | 100 | 988 |
第四次排序:3 | 12 | 2 | 5 | 33 | 23 | 18 | 66 | 99 | 100 | 988 |
第五次排序:3 | 2 | 5 | 12 | 23 | 18 | 33 | 66 | 99 | 100 | 988 |
第六次排序:2 | 3 | 5 | 12 | 18 | 23 | 33 | 66 | 99 | 100 | 988 |

代码如下

    public static void main(String[] args){
        int number[] = {988,3,12,99,100,33,2,5,66,23,18};
        int temp;
        int len = number.length;
        a:for (int k = 0; k<len-1;k++) {
            for (int i = 0; i < len - 1-k; i++) {
                if (number[i] > number[i + 1]) {
                    temp = number[i];
                    number[i] = number[i + 1];
                    number[i + 1] = temp;
                }
            }
            System.out.print("第"+k+"次\t");
            for(int j= 0;j<number.length;j++){
                System.out.print(number[j]+" | ");
            }
            System.out.print("\n\r");
        }

    }

执行结果如下:

优化冒泡排序

第一次优化:
从上图中我们可以看到在图中的第五次(实际为第六次)的时候已经完成了排序,但是程序还是继续完成了所有循环.所以首先我们第一次优化将多余的循环次数减少;
我们可以再程序中加入一个标识,来判断排序是否已经完成,要是完成了直接跳出循环;
不墨迹直接上代码:

        public static void main(String[] args){
        int number[] = {988,3,12,99,100,33,2,5,66,23,18};
        int temp;
        int len = number.length;
        boolean pos = true;
        int a = 0;
        a:for (int k = 0; k<len-1;k++) {
            for (int i = 0; i < len - 1-k; i++) {
                if (number[i] > number[i + 1]) {
                    temp = number[i];
                    number[i] = number[i + 1];
                    number[i + 1] = temp;
                    pos=false;
                }else {
                    a++;
                    if(a==len - 1-k){
                        pos=true;
                        a=0;
                    }
                }
            }
            if(pos){
                break a;
            }
            System.out.print("第"+k+"次\t");
            for(int j= 0;j<number.length;j++){
                System.out.print(number[j]+" | ");
            }
            System.out.print("\n\r");
        }

    }

执行结果如下图:

可以看到在第五次的时候完成了排序,同事也跳出了循环,结束程序;是不是感觉好多了呢.

第二次优化:
现在只是每次循环的时候把最大的数排到最后,现在我们同时把最小的数排到最前面,这样就大大提高了效率,看代码:

public static void main(String[] args){
        int number[] = {988,3,12,99,100,33,2,5,66,23,18};
        int temp;
        int len = number.length;
        boolean pos = true;
        int a = 0;
        int b = 0;
        a:for (int k = 0; k<len-1;k++) {
            for (int i = 0; i < len - 1-k; i++) {
                if (number[i] > number[i + 1]) {
                    temp = number[i];
                    number[i] = number[i + 1];
                    number[i + 1] = temp;
                    pos=false;
                }else {
                    a++;
                    if(a==len - 1-k){
                        pos=true;
                        a=0;
                    }
                }
            }
            for (int f = len-1 ;f>0;f--){
                if(number[f]<number[f-1]){
                    temp = number[f];
                    number[f]=number[f-1];
                    number[f-1]=temp;
                    pos=false;
                }else {
                    b++;
                    if(b==len-1){
                        pos=true;
                        b=0;
                    }
                }
            }
            if(pos){
                break a;
            }
            System.out.print("第"+k+"次\t");
            for(int j= 0;j<number.length;j++){
                System.out.print(number[j]+" | ");
            }
            System.out.print("\n\r");
        }

    }

结果如图

可以看到只用了三次就排序好了.

好啦,暂时只能想到这么多啦,代码的写法上还有优化的地方,请各位大神多多指教啦!