插入排序 冒泡 选择 快速

package test;

public class Demo5_3 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		int arr1[] = { 1, 6, 0, -1, 9, 3, 2, 44, 33, 77 };

		// 用插入法定义一个对象
		InsertSort is = new InsertSort();

		is.sort(arr1);
		System.out.println(arr1);
	}
}

/*
 * 1插入排序 已知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、b[2]、……b[m]，需将二者合并成一个升序数列。首先比较b[1
 * ]与a[1]的值
 * ，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值，若b[1]仍然大于a[2]，则继续跳过，直到b[1]小于a数组中某一数据a[x
 * ]，则将a[x]
 * ~a[n]分别向后移动一位，将b[1]插入到原来a[x]的位置这就完成了b[1]的插入。b[2]~b[m]用相同方法插入。（若无数组a，可将b
 * [1]当作n=1的数组a）
 * 
 * 优点：稳定，快； 缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。
 */
class InsertSort {
	// 插入排序法
	public void sort(int arr[]) {
		for (int i = 1; i < arr.length; i++) {
			int insertVal = arr[i];
			// insertVal准备和前一个数比较
			int index = i - 1;
			while (index >= 0 && insertVal < arr[index]) {
				// 将把arr[index]向后移动
				arr[index + 1] = arr[index];
				// 让index 向前移动
				index--;
			}
			// 将insertVal 插入到适当的位置
			arr[index + 1] = insertVal;
		}
	}
}

/*
 * 1 选择排序
 * 已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不变
 * 。再比较a
 * [1]与a[3]的值，若a[1]大于a[3]则交换两者的值，否则不变。再比较a[1]与a[4]，以此类推，最后比较a[1]与a[n]的值。这样处理一轮后
 * ，a
 * [1]的值一定是这组数据中最小的。再将a[2]与a[3]~a[n]以相同方法比较一轮，则a[2]的值一定是a[2]~a[n]中最小的。再将a[3]与a[
 * 4]~a[n]以相同方法比较一轮，以此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序排列了。
 * 
 * 优点：稳定，比较次数与冒泡排序一样； 缺点：相对之下还是慢。
 */
class Select {
	// 选择快排序
	int temp = 0;

	public void sort(int arr[]) {
		// 认为第一个数字是最小的
		int temp = 0;
		for (int j = 0; j < arr.length - 1; j++) {
			int min = arr[j];
			// 记录最小数的下标
			int minIndex = j;
			for (int k = j + 1; k < arr.length; k++)
				if (min > arr[k]) {
					min = arr[k];
					minIndex = k;
				}
			temp = arr[j];
			arr[j] = arr[minIndex];
			arr[minIndex] = temp;
		}
	}
}

/*
 * 3、冒泡排序 已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与 a[2]的值，若a[1]大于a[2]则交换
 * 两者的值，否则不变。再比较a[2]与a[3]的值，若a[2]大于a[3]则交换两者的值，否则不变。再比 较a[3]与a[4]，以此
 * 类推，最后比较a[n-1]与a[n]的值。这样处理一轮后，a[n]的值一定是这组数据中最大的。再对a[1]~a[n- 1]以相同方法
 * 处理一轮，则a[n-1]的值一定是a[1]~a[n-1]中最大的。再对a[1]~a[n-2]以相同方法处理一轮，以此类推。共处理 n-1 轮
 * 后a[1]、a[2]、……a[n]就以升序排列了。
 * 
 * 优点：稳定； 缺点：慢，每次只能移动相邻两个数据。
 */
class Bubble {
	public void test(int a) {
		a++;
	}

	public void sort(int arr[]) {
		int temp = 0;
		// i是决定走几趟, 冒泡排序
		for (int i = 0; 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;
				}
			}
		}
	}
}

/*
 * 4:快速排序
 * 快速排序，是最常用的排序算法，就是选择待排序的列表中的其中一个数字，作为基准数，然后把小于基准数的所有数字放到这个数的左边，大于这个数的所有数字放到基准数的右边
 * 。这个时候开始分为两部分，左边和右边。第一部分，在左边中选择一个数字作为基准数，把小于这个数字的放到这个数的左边，大于这个数的放到这个数的右边。第二部分，
 * 在右边中选择一个数字作为基准数，把小于这个数字的放到这个数的左边，大于这个数的放到这个数的右边。ok，很明显，递归！
 * 
 * 快速排序的时间复杂度在最坏的情况下是O(N2)，因为和冒泡排序一样，需要两两交换。平均情况下，快速排序的时间复杂度是O(NlogN)。
 * 
 * 
 * 
 * 优点：极快，数据移动少； 缺点：不稳定。
 */
class QuickSort {
	public void sort(int[] a, int low, int high) {

		int pos;
		if (low < high) {
			pos = FindPos(a, low, high);
			sort(a, low, pos - 1);
			sort(a, pos + 1, high);
		}
	}

	public int FindPos(int[] a, int low, int high) {
		int val = a[low];
		while (low < high) {
			while (low < high && a[high] >= val)
				--high;
			a[low] = a[high];
			while (low < high && a[low] <= val)
				++low;
			a[high] = a[low];
		}
		a[low] = val;
		return low;
	}
}