交换式排序法之冒泡排序法实现-java版

//这里涉及一个数组引用的传递，在DemoBubble类里面对Bubble类Sort方法调用传递了一个数组应用，在Sort方法里面对数组的更改都会更改实参。这就类似于C语言里面传递的数组地址。

package com.PengRong.A;

import java.util.*;

public class DemoBubble {

 public static void main(String[] args)
 {
  // TODO Auto-generated method stub
  //随机产生十万个测试数据
  int len=100000;
  int[] arr =new int[len];
  for(int i=0; i<len; i++)
  {
   int t =(int)(Math.random()*10000);
   arr[i] =t;
  }

  Bubble bubble =new Bubble();
  bubble.Test();
  bubble.Sort(arr);
  bubble.Test();
  /*for(int i=0; i<arr.length; i++)
  {
   System.out.println("arr[" +i+ "]="+arr[i]);
  }
*/
 }

}
/**
 * @功能：冒泡排序实现，没有记录每趟是否有交换数据的行为
 * 冒泡排序的核心思想重复的从开始到末端遍历数组，
 *  每次遍历排序后都使得当前待排序数据组中最大值排到合适的最后位置，
 * 比如第一趟排序是最大数到最后
 * @author PengRong
 *
 */
class Bubble
{
 public void Test()
 {
  Calendar cal =Calendar.getInstance();
  System.out.println(cal.getTime());
 }
 /**
  * @author PengRong
  * @Function 冒泡排序的实现算法，实现对一个int型数组的数字按从小到大排序
  * @param arr
  */
 public void Sort(int[] arr)
 {
  int temp =0;
  //外层循环控制冒泡排序总共需要走几趟
  for(int i=0; i<arr.length-1; i++)
   {
    //内层循环控制每趟排序需要做多少次比较,arr.length-1指的是最大可执行比较次数
    //因为每趟都会在数组末端沉淀一个最大数所以减去i
    for(int j=0; j<arr.length-1-i; j++)
    {
     if(arr[j]>arr[j+1])
     {
      temp = arr[j];
      arr[j] = arr[j+1];
      arr[j+1] =temp;

     }
    }
   }

 }
}

/**
相比上一次的改进是增加了一个记录字段exchange
*/
public static void bubbleSort(int[] table) {
        boolean exchange = true;// 一趟比较下来是否交换的标记
        for (int i = 1; i < table.length && exchange; i++) {// 总共比较n-1趟，每趟使得的最大值在沉入数组下面
            exchange = false;// 标记还没有交换
            for (int j = 0; j < table.length - i; j++) // 每趟比较n-i次
                if (table[j] > table[j + 1]) {
                    int temp = table[j];
                    table[j] = table[j + 1];
                    table[j + 1] = temp;
                    exchange = true;
                }
        }
    }

该历程实现了对系统时间的显示，以观察冒泡排序法的时间复杂度
当int len =10000时候，用时看不到明显流失。

当int len =80000时候，用时22s，时间已经很多了。

当int len = 100000时候，用时高达26s；确实很慢