java 排序算法(冒泡)

最近想把排序算法重新复习下，顺便理理思路。

首先冒泡排序。

说白了，冒泡排序就是一对对的比较，然后swap，在思路上来说没啥子其他的了。

不过在实现的时候可以发现，外循环其实每循环一次都可以减少一次，因为第一次外循环的时候 冒泡排序把最大的数移动到了最后面，第二次循环的时候也是把第二大的数移到

倒数第二个位置…………依次可以减少下内循环的次数。

看一个最直观的代码(最直观也就最可能是最差的代码)

	public int[] bubble(int[] arr){
		int temp;
		int h=0;
		for(int j=0; j< arr.length; j++){
			h++;
			for(int i=0; i< arr.length-1; i++){
				if(arr[i] > arr[i+1]){
					temp = arr[i+1];
					arr[i+1] = arr[i];
					arr[i] = temp;
				}
			}
		}
		return arr;
	}

下面简略的测试下时间消耗

	public static void main(String[] args) {
		TestBubble bubble = new TestBubble();
		int[] arry = new int[10000];
		for(int i=9999; i>=0; i--){
			arry[i] = 9999-i;
		}
		long startTime = System.currentTimeMillis();//毫秒
		bubble.bubble(arry);
		long endTime = System.currentTimeMillis();
		System.out.println("Time:"+(endTime-startTime)+"ms");
	}

稍微修改下代码，把第二个for循环中的arr.length-1改为-h

			for(int i=0; i< arr.length-h; i++){

消耗时间如下：

代码再稍微改一点：如下

	public int[]  bubbleSort(int[] arr) {
	      boolean swapped = true;
	      int j = 0;
	      int tmp;
	      while (swapped) {
	            swapped = false;
	            j++;
	            for (int i = 0; i < arr.length - j; i++) {                                       
	                  if (arr[i] > arr[i + 1]) {                          
	                        tmp = arr[i];
	                        arr[i] = arr[i + 1];
	                        arr[i + 1] = tmp;
	                        swapped = true;
	                  }
	            }                
	      }
	      return arr;
	}

运行时间如下：

我以为出了问题，把时间改成System.nanoTime()纳秒

结果如下：

我特地百度了下，纳秒和毫秒的关系1s=1000ms=1000000微秒=1000000000纳秒=1000000000000皮秒
这个速度就更好了点，具体原因没想出来，for循环变成了while，缺少了arr.length，还有i++的过程，这个差距也有点猛哦。

当然我这个初始化的数组也有点坑的感觉，完全是相反的，哈哈。

冒泡排序花费的时间与初始化的数据顺序还是具有很大关系的。

同时在冒泡排序中有个说法，就是乌龟和兔子。

乌龟指的就是冒泡排序中小的数走的特别慢，兔子指的是大数据走的特别快，看下面两个图就很明显了

上图是小数也就是乌龟数。

上图是大数也就是兔子数。