简单排序：冒泡排序、选择排序和插入排序

package structure;

/**
 * 简单排序的几种方式:冒泡排序、选择排序和插入排序,时间复杂度基本都为O(n*n)<br>
 * 冒泡排序效率最低,选择排序则减少了元素交换的次数,而插入排序是3种方式中效率最高的<br>
 * 特别是当元素基本有序的情况下, 插入排序其平均时间复杂度接近O(n) <br />
 * 
 * 除此之外复杂但更高效的排序方式还有：希尔排序和快速排序
 * 
 * @author yli
 * 
 */
public class SortDemo {

	public static void main(String[] args) {
		// 冒泡排序：升序
		popSortAsc();
		// 冒泡排序：降序
		popSortDesc();

		// 选择排序：升序
		selectedSortAsc();
		// 选择排序：降序
		selectedSortDesc();

		// 插入排序：升序
		insertSortAsc();
		// 插入排序：降序
		insertSortDesc();
	}

	/**
	 * 冒泡排序：升序方式排序<br>
	 * 冒泡排序特点：n个元素需要执行(n-1)次冒泡排序,第i轮冒泡有 (n-1-i)个元素需要两两比较<br>
	 * 并且两两比较,只要满足比较条件,则相邻元素就交换,这其实就是和选择排序最大的区别
	 */
	public static void popSortAsc() {
		int[] a = { 10, 4, 3, 6, 5, 7, 2, 1, 9, 8 };
		int temp;
		// n 个元素,需要执行 n-1 轮冒泡排序
		int popCount = a.length - 1;
		for (int i = 0; i < popCount; i++) {
			// 第i轮冒泡就还有 (n-1-i)个元素需要两两比较
			for (int j = 0; j < popCount - i; j++) {
				if (a[j] > a[j + 1]) {
					// 相邻两个元素比较只要符合条件,那么两个元素就进行交换
					// 并且发现外层循环和内部循环中的元素没有关系
					// 因此外层循环是计算：总共需要执行多少轮冒泡排序
					// 而内部循环是：对剩余还未排序的元素进行一轮冒泡排序
					temp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = temp;
				}
			}
		}

		print(a);
	}

	/**
	 * 冒泡排序：降序方式排序
	 */
	public static void popSortDesc() {
		int[] a = { 10, 4, 3, 6, 5, 7, 2, 1, 9, 8 };
		int temp;
		int popCount = a.length - 1;
		for (int i = 0; i < popCount; i++) {
			for (int j = 0; j < popCount - i; j++) {
				// 升序和降序,只要改变比较方式即可
				if (a[j] < a[j + 1]) {
					temp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = temp;
				}
			}
		}

		print(a);
	}

	/**
	 * 比较排序：升序方式排序<br>
	 * 比较排序特点：和冒泡排序类似,n个元素,需要执行(n-1)轮选择排序<br>
	 * 执行第i轮排序,假设a[i]为最小元素,从剩余的a[i+1]到a[len-1]中记录比a[i]还小的元素的位置<br>
	 * 最后再拿a[i]和a[minIndex]进行交换,和冒泡排序相比,速度更快,因为节省了多次交换的时间<br>
	 * 对于那些交换需要花费更多时间的编程语言来说,选择排序无疑比冒泡排序更优<br>
	 */
	public static void selectedSortAsc() {
		int[] a = { 10, 4, 3, 6, 5, 7, 2, 1, 9, 8 };
		int minIndex;
		int temp;
		for (int i = 0; i < a.length - 1; i++) {
			// 假设a[i]是当前最小元素
			minIndex = i;

			// 从a[i+1]到a[len-1]中选出比a[i]还小的元素
			for (int j = i + 1; j < a.length; j++) {

				// 和冒泡排序相比,只从待排序元素中选出最小元素,并记录其位置
				if (a[minIndex] > a[j]) {
					minIndex = j;
				}
			}
			// 等一轮选择排序执行完之后再交换
			if (i != minIndex) {
				temp = a[i];
				a[i] = a[minIndex];
				a[minIndex] = temp;
			}
		}

		print(a);
	}

	/**
	 * 比较排序：降序方式排序
	 */
	public static void selectedSortDesc() {
		int[] a = { 10, 4, 3, 6, 5, 7, 2, 1, 9, 8 };
		int minIndex;
		int temp;
		for (int i = 0; i < a.length - 1; i++) {
			minIndex = i;
			for (int j = i + 1; j < a.length; j++) {
				if (a[minIndex] < a[j]) {
					minIndex = j;
				}
			}
			if (i != minIndex) {
				temp = a[i];
				a[i] = a[minIndex];
				a[minIndex] = temp;
			}
		}

		print(a);
	}

	/**
	 * 插入排序：升序方式排序<br>
	 * 插入排序的特点：局部有序,待排序的元素在有序的元素中找到一个合适的位置插入<br>
	 * 大约比冒泡排序快1倍,比选择排序略快<br>
	 * 这种排序方式特别适合基本有序的元素排序,其排序速度接近 O(n)<br>
	 * 不过正常情况下,其排序速度也要计算为 O(n*n)
	 * 
	 */
	public static void insertSortAsc() {
		int[] a = { 10, 4, 3, 6, 5, 7, 2, 1, 9, 8 };
		int j;
		int temp;
		// 假设a[0]为局部有序的元素(因为只有一个,所以肯定是有序)
		// 然后从a[1]开始往局部有序的元素中插入新元素
		for (int i = 1; i < a.length; i++) {
			j = i;
			// 第[i]轮排序,要插入的新元素就是 a[i]
			temp = a[i];
			// 然后找到新元素在局部有序元素中的位置
			while (j > 0 && a[j - 1] > temp) {
				a[j] = a[j - 1];
				j--;
			}
			a[j] = temp;
		}

		print(a);
	}

	/**
	 * 插入排序：降序方式排序
	 */
	public static void insertSortDesc() {
		int[] a = { 10, 4, 3, 6, 5, 7, 2, 1, 9, 8 };
		int j;
		int temp;
		for (int i = 1; i < a.length; i++) {
			j = i;
			temp = a[i];
			// 升序和降序,只要改变比较方式即可
			while (j > 0 && a[j - 1] < temp) {
				a[j] = a[j - 1];
				j--;
			}
			a[j] = temp;
		}

		print(a);
	}

	private static void print(int[] arr) {
		for (int temp : arr) {
			System.out.print(temp + "\t");
		}
		System.out.println();
	}

}