排序算法

1、直接插入排序

直接插入排序是插入排序的一种，插入排序还包括希尔排序、折半插入排序。

插入排序：每次从无序表中取出第一个元素，把它插入到有序表的合适位置，使有序表仍然有序。

算法：首先在当前有序区R[1..i-1]中查找R[ i]的正确插入位置k(1≤k≤i-1)；然后将R[k．．i-1]中的元素均后移一个位置，腾出k位置上的空间插入R[i]。

public static void insertSort(int[] arr) {
		// 外层循环决定待比较的数值，内层循环决定待比较数值最终位置
		for (int i = 1; i < arr.length; i++) {// 循环从第二个元素开始
			if (arr[i] < arr[i - 1]) {// 如果第i位小于第i-1位，继续寻位并插入
				int temp = arr[i];
				int j;
				for (j = i - 1; j >= 0 && arr[j] > temp; j--) {// 从i-1位遍历直到找到小于第i位值停止

					arr[j + 1] = arr[j];// k元素都后移一位
				}
				// 跳出循环说明j后面的位置就是要插入的位置
				arr[j + 1] = temp;
			}
		}
}

2、希尔排序

希尔排序:是针对直接插入排序算法的改进，是将整个无序列分割成若干小的子序列分别进行插入排序。

算法：先取一个正整数d1<n(一般取数组长度的一般作为d1)，把所有序号相隔d1的数组元素放一组，组内进行直接插入排序；然后取d2<d1(一般取d1的1半)，重复上述分组和排序操作；直至di=1， 即所有记录放进一个组中排序为止。

如：假设数组{13，3，55，6，9，4，23，2}则d的取值依次为4，2，1。3组数组索引分别为{4，5，6，7}{2，4，6，3，5，7}{1，2，3，4，5，6，7}

public static void shellSort(int[] arr) {
		int d = arr.length;
		while (true) {
			d = d / 2;			
			for (int x = 0; x < d; x++) {
				//对子序列进行插入排序
				for (int i = x + d; i < arr.length; i = i + d) {
					int temp = arr[i];
					int j;
					for (j = i - d; j >= 0 && arr[j] > temp; j = j - d) {
						arr[j + d] = arr[j];
					}
					System.out.print(i + ",");
					arr[j + d] = temp;
				}
				System.out.println();
			}
			if (d == 1) {
				break;
			}
		}
}

3、冒泡排序

冒泡排序：冒泡排序就是把小的元素往前调，把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。

算法：将相邻两个元素进行比较，如果第一个比第二个大则交换他们的位置，从开始第一对到结尾最后一对做相同的工作，外循环一次，最值出现在最后位。重复以上步骤，直到没有需要比较的一对数字。 算法的时间复杂度为O(n^2)。

private static void bubbleSort(int[] arr) {
	// 外循环控制比较的次数arr.length-1，内循环控制相邻两元素间的比较。
	for (int i = 0; i < arr.length - 1; i++) {
		for (int j = 0; j < arr.length - i - 1; j++) {// -x:每次比较元素减少，-1：防止角标越界
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

4、快速排序

快速排序是对冒泡排序的一种改进。

快速排序：通过一趟排序将要排序的数据分割成两部分，其中左边的数据都比右边的数据小，然后再对每部分进行一趟排序。算法：一趟排序--首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，由后（j--）开始向前搜索， 将找到第一个小于key的数放在i，在由前向后(i++)搜索，将找到的第一个大于key的数放在j。重复以上步骤，值到i =j。

private static void quickSort(int[] arr, int first, int end) {
	if (first >= end) {
		return;
	}
	int f = first;
	int e = end;
	int key = arr[first];

	while (f < e) {
		while (f < e && arr[e] > key) {// 从后向前搜索比key小的值
			e--;
		}
		arr[f] = arr[e];// 将比key小的元素移到左边
		System.out.print(1 + ":");
		printArr(arr);
		while (f < e && arr[f] < key) {// 从前向后搜索比key大的值
			f++;
		}
		arr[e] = arr[f];// 将比key大的元素移到右边
		System.out.print(2 + ":");
		printArr(arr);
	}
	arr[f] = key;// 执行此步跳出循环表示f==e,把中间数key赋值给f
	System.out.print(3 + ":");
	printArr(arr);
	quickSort(arr, first, f - 1);// 对左边数据进行递归快速排序
	quickSort(arr, e + 1, end);
}	 

5、选择排序

选择排序：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完

算法：第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]~arr[n-1]中选取最小值，与arr [1]交换, 第n-1次从arr[n-2]~arr[n-1]选取最小值与arr[n-2]交换，总共进行n-1次得到有序数列。 

private static void selectSort(int[] arr) {
	// 外循环决定选取的次数，内循环决定每次的最小值
	for (int i = 0; i < arr.length - 1; i++) {
		for (int j = i; j < arr.length - 1; j++) {
			if (arr[i] > arr[j]) {
				int temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
	}
}