冒泡排序

package com.algorithm.code;

import java.util.Arrays;

/**
 * 冒泡排序
 * @author lenovo
 *
 */
public class BubbleSort {
	
	public static void main(String[] args) {
		int[] array = new int[] {6,7,5,2,8,9};
		sort1(array);
		//sort2(array);
		//sort3(array);
		System.out.println(Arrays.toString(array));
	}

	/**
	 * 冒泡排序第一版：普通版
	 * @param array
	 */
	public static void sort1(int[] array) {
		for(int i = 0; i < array.length - 1; i++) {
			for(int j = 0; j < array.length - i - 1; j++) {
				int temp = 0;
				if(array[j] > array[j+1]) {
					temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
	}
	
	/**
	 * 冒泡排序第二版
	 * 假定数组为[1,2,4,8,7,5]
	 * 第一轮排序：[1,2,4,7,5,8]
	 * 第二轮排序：[1,2,4,5,7,8]
	 * 第二轮排序之后，在进行第三轮比较之后，发现并未有任何的元素交换，
	 * 则代表该数组已经是有序的了，不用在进行后续的比较了
	 * @param array
	 */
	public static void sort2(int[] array) {
		for(int i = 0; i < array.length - 1; i++) {
			//定义一个布尔值，判断每次循环时，是否有元素进行交换
			//如果没有元素进行交换，则表示剩下的元素已经是有序的了，不用再进行遍历比较交换了
			boolean isSorted = true;
			for(int j = 0; j < array.length - i - 1; j++) {
				int temp = 0;
				if(array[j] > array[j+1]) {
					temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
					//进入这个if条件，则表示有元素进行交换，把isSorted置为false
					isSorted = false;
				}
			}
			//当未发现排序时，直接结束外层循环
			if(isSorted) {
				break;
			}
		}
	}
	
	/**
	 * 冒泡排序第三版
	 * 假定数组为[4,2,1,5,7,8,9]
	 * 第一轮排序：[2,1,4,5,7,8,9]
	 * 我们发现，第一轮排序的时候，发生交换的最远位置是在index为1的地方，
	 * 后面的5,7,8,9是有序的，并未发生任何的元素交换，
	 * 所以，后续的遍历我们只遍历前面部分的元素
	 * @param array
	 */
	public static void sort3(int[] array) {
		//记录最后一次发生元素交换的位置
		int lastExchangeIndex = 0;
		//无序数组的边界，后面的元素是有序的，不需要在比较了，只遍历比较前面的元素
		int sortBorder = array.length - 1;
		for(int i = 0; i < array.length - 1; i++) {
			//定义一个布尔值，判断每次循环时，是否有元素进行交换
			//如果没有元素进行交换，则表示剩下的元素已经是有序的了，不用再进行遍历比较交换了
			boolean isSorted = true;
			for(int j = 0; j < sortBorder; j++) {
				int temp = 0;
				if(array[j] > array[j+1]) {
					temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
					//进入这个if条件，则表示有元素进行交换，把isSorted置为false
					isSorted = false;
					//记录交换的位置
					lastExchangeIndex = j;
				}
			}
			sortBorder = lastExchangeIndex;
			//当未发现排序时，直接结束外层循环
			if(isSorted) {
				break;
			}
		}
	}
}