冒泡排序-java

冒泡排序：这是一个经典的排序算法。通过遍历数组，相邻两个元素进行比较，每次将数值较大的元素排到后面。如果数组长度为n，则遍历n-1次得到有序数组。冒泡排序的时间复杂度为O(n^2)-----n个数，遍历n-1次

      优化：添加一个标记，如果遍历数组中发生了交换，则标记为true；否则为false。如果某一趟没有发生交换，说明数组此时有序

      冒泡排序是稳定的，因为数值相等的元素不会发生交换

package sort;

public class BubbleSort {

    /*
    * 冒泡排序
    * 参数说明：
    *   a--待排序的数组
    *   n--数组的长度
    * */
    public static void bubbleSort1(int[] a,int n){
        int i,j;
        for(i=n-1;i>0;i--){
            //将a[0...i]中最大的数放在末尾
            for (j=0;j<i;j++){
                if(a[j]>a[j+1]){
                    //交换a[j]和a[j+1]
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
    }

    /*
    * 冒泡排序（改进版）
    *
    * 参数说明：
    *   a--待排序的数组
    *   n--数组的长度
    * */
    public static void bubbleSort2(int[] a,int n){
        int i,j;
        int flag=0;   //标记,初始化为0
        for(i=n-1;i>0;i--){
            //将a[0...i]中最大的数放在末尾
            for (j=0;j<i;j++){
                if(a[j]>a[j+1]){
                    //交换a[j]和a[j+1]
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                    flag=1; //若发生交换，则社标记为1
                }
            }
            /*
            * 如果某一趟遍历中发现没有发生交换，说明排序已经完成
            * */
            if(flag==0){
                break;
            }
        }
    }


    public static void main(String[] args){

        int i;
        int[] a={20,40,30,10,60,50};

        System.out.println("before sort:");
        for (i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();

        bubbleSort1(a,a.length);

        System.out.println("after sort:");
        for (i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
    }
}