三种冒泡算法

package yunnex.mobile;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import yunnex.foundation.base.entity.Province;
import yunnex.foundation.base.service.ProvinceService;
import yunnex.saofu.mall.constants.MallProductOrderStatus;
import yunnex.saofu.mall.dto.order.MallProductOrderDto;
import yunnex.saofu.mall.service.order.ExtProductOrderService;

import java.lang.reflect.Array;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.List;

public class TestMath {

/**
 * 冒泡排序的第一种实现, 没有任何优化
 * @param a
 * @param n
 */
private static void BubbleSort1(int [] a, int n){
    int i, j;
    int num=0;
    for(i=0; i<n; i++){  //表示n次排序过程。
        for(j=1; j<n-i; j++){
            if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换
                //交换a[j-1]和a[j]
                int temp;
                temp = a[j-1];
                a[j-1] = a[j];
                a[j]=temp;
            }
            num++;
        }
    }
    System.out.println("num:"+num);
}

/**
 * 设置一个标志，如果这一趟发生了交换，则为true，否则为false。明显如果有一趟没有发生交换，说明排序已经完成。
 * @param a
 * @param n
 */
private static void BubbleSort2(int [] a, int n){
    int j, k = n;
    boolean flag = true;//发生了交换就为true, 没发生就为false，第一次判断时必须标志位true。
    while (flag){
        flag=false;//每次开始排序前，都设置flag为未排序过]
        for(j=1; j<k; j++){
            if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换
                //交换a[j-1]和a[j]
                int temp;
                temp = a[j-1];
                a[j-1] = a[j];
                a[j]=temp;
                //表示交换过数据;
                flag = true;
            }
        }
        k--;//减小一次排序的尾边界
    }
}

/**
 * 设置一个标志，如果这一趟发生了交换，则为true，否则为false。明显如果有一趟没有发生交换，说明排序已经完成。
 * @param a
 * @param n
 */
private static void BubbleSort3(int [] a, int n){
    int j, k;
    int flag = n;
    while (flag>0){
        k=flag;
        flag=0;//每次开始排序前，都设置flag为未排序过]
        for(j=1; j<k; j++){
            if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换
                int temp;
                temp = a[j-1];
                a[j-1] = a[j];
                a[j]=temp;

                //表示交换过数据;
                flag = j;
            }
        }
    }
}



public static void main(String[] args) {
    int[] arr = {1,1,2,0,9,3,12,7,8,3,4,65,22};
    long time1=System.nanoTime();
    BubbleSort1(arr, arr.length);
    long time2=System.nanoTime();
    System.out.println("time1:"+(time2-time1));
    long time3=System.nanoTime();
    BubbleSort2(arr, arr.length);
    long time4=System.nanoTime();
    System.out.println("time2:"+(time4-time3));
    long time5=System.nanoTime();
    BubbleSort3(arr, arr.length);
    long time6=System.nanoTime();
    System.out.println("time3:"+(time6-time5));

    System.out.println(Arrays.toString(arr));
}

}