java冒泡排序算法

冒泡排序

冒泡排序：两个数比较大小，较大的数下沉，较小的数冒起来。

具体排序方式（从小到大）：将最前面相邻两个数进行比较大小，把大的排到后面，然后比较第二个和第三个这相邻两个数，以此方式一轮下来，最大的那个数就会被排到最后面，这一轮总共比较了n-1次（n为数组长度），再进行第二轮，这时要比较的次数是n-2次，而第二大的那个数被排在了倒数第二位，以此下来，最终得到排序后的数组。

按照原理，我们写了以下这个方法：

public class BubbleAlgorithm {

    public static int[] bubbleSort(int[] arr){
            //判断数组是否为空或者长度为1
            if (arr==null||arr.length<1){
                return null;
            }

            int n=arr.length;
            int index=0;

            for (int i=0;i<n;i++){
                for (int j=1;j<n-i;j++){
                    if (arr[j-1]>arr[j]){
                        int temp;
                        temp=arr[j-1];
                        arr[j-1]=arr[j];
                        arr[j]=temp;
                    }
                    index++;
                }
            }

            System.out.println("index="+index);
            return arr;
        }

}

在方法里面，我们加入了index统计总共遍历的次数，

以下我们提供了一个测试的方法，

public static void main(String[] args) {

        int[] arr={23,6,54,2,4,44,33,52,236,552};

        arr=BubbleAlgorithm.bubbleSort(arr);

        for (int index:arr) {
            System.out.println(index + ",");
        }
    }

运行结果为：

index=45
2,
4,
6,
23,
33,
44,
52,
54,
236,
552,

当然，如果数组在进行到第2轮比较结束后就已经得到排序后的数组，而按照上面的写法是要等到第9轮结束后才能得到最终数组，这时候就应该进行优化处理了，加入一个标签进行判断，当进行到第m轮的时候已经得到最终数组，那么就该退出循环，返回最终数组。

以下是根据描述进行的修改：

public static int[] bubbleSort2(int[] arr){
        //判断数组是否为空或者长度为1
        if (arr==null||arr.length<1){
            return null;
        }

        int n=arr.length;
        int index=0;

        boolean flag=true;
        int k=0;

        while (flag){
            flag=false;
            for (int j=1;j<n-k;j++){
                if (arr[j-1]>arr[j]){
                    int temp;
                    temp=arr[j-1];
                    arr[j-1]=arr[j];
                    arr[j]=temp;

                    flag=true;
                }
                index++;
            }
            k++;
        }

        System.out.println("index="+index);
        return arr;
    }

利用上面的测试代码，我们再运行一下：

index=30
2,
4,
6,
23,
33,
44,
52,
54,
236,
552,

同样的数组，整整少了15次遍历，相对于第一种排序方法优化很多。

上面那种情况是针对于遍历过程中完成最终排序数组的，那么如果只是部分排序
完成的情况呢，比如排序过程中，第一遍下来，100个数，后面50个已经排序完成，而前面50个还处于错序当中，那么其实后面50个数就不需要再进行排序了，因为这样会消耗不必要的时间，而按照上面排序的写法，后面50个数必然还要经过很多遍的比较，所以再次思考一下，要怎么才能让算法更优。

其实只要增加一个值去记录位置，然后在遍历过程中，不断的缩小遍历的范围（需要排序的区间），这样就可以减少不必要的性能损耗。

以下是根据思路进行的写法：

public static int[] bubbleSort3(int[] arr){
        //判断数组是否为空或者长度为1
        if (arr==null||arr.length<1){
            return null;
        }

        int n=arr.length;
        int index=0;

        int k=0,m=0;
        int flag=n;

        while (flag>0){
            k=flag;
            flag=0;
            for (int j=1;j<k;j++){
                if (arr[j-1]>arr[j]){
                    int temp;
                    temp=arr[j-1];
                    arr[j-1]=arr[j];
                    arr[j]=temp;

                    flag=j;

                }
                index++;
            }
        }

        System.out.println("index="+index);
        return arr;
    }

然后还是拿那段代码和数组测试一下：

index=20
2,
4,
6,
23,
33,
44,
52,
54,
236,
552,

这次只不过遍历了20次就完成了最终的数组排序，可见优化之后的算法性能更高。

冒泡排序的学习到此为止。

QQ：361561789

冒泡排序

猜你喜欢