几种排序算法的时间比较

1.冒泡排序

特点：效率低，实现简单
原理：从第一个位置开始，依次往后，相邻的数相比较。若前面的数比前面的大，替换位置，直到最后。每一轮遍历即可遍历出剩下数中最大的值。

/**
 * 冒泡排序
 */
public static int[] maoPao(int[] array) {
    int temp = 0;
	for (int i = 1; i < array.length; i++) {
		for (int j = 0; j < array.length - 1; j++) {
			if (array[j] > array[j + 1]) {
				temp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = temp;
			}
		}
	}
	return array;
}

2.选择排序

特点：效率低，容易实现。
原理：每一趟从待排序序列选择一个最小的元素放到已排好序的位置上，剩下的数重复上述步骤。

/**
 * 选择排序
 */
public static void xuanZe(int[] array) {
	int index = 0;
	int temp = 0;
	for (int i = 0; i < array.length - 1; i++) {
		index = i;
		for (int j = i + 1; j < array.length; j++) {
			if (array[index] > array[j]) {
				index = j;//筛选出最小数的位置
			}
		}
		if (i != index) {//把剩下数中筛选出的最小数放在已排好的位置上
			temp = array[index];
			array[index] = array[i];
			array[i] = temp;
		}
	}
}

3.插入排序

特点：效率低，容易实现。
原理：从第二个数开始，依次和前面的数比较，若比前面的数小，则和前面的数交换位置，一直比较到已排好的位置

对比冒泡排序：类似冒泡，但冒泡约往后，每次需遍历数越少。插入排序相反，越往后需要遍历的数越多。

/**
 * 插入排序
 */
public static void chaRu(int[] array) {
	int temp;
	for (int i = 1; i < array.length; i++) {
		int j = i;
		temp = array[i];//待插入目标数
		while (j > 0 && temp < array[j - 1]) {
			array[j] = array[j - 1];
			j--;
		}
		array[j] = temp;//放入目标位置
	}
}

扫描二维码关注公众号，回复： 16438996 查看本文章

4.快速排序

特点：高效，时间复杂度为nlogn。
原理：采用分治法的思想：首先设置一个中间值，然后以这个中间值为划分基准将待排序序列分成比该值大和比该值小的两部分，将这两部分再分别进行快速排序，直到序列只剩下一个元素(中间值的选取。影响到排序的时间复杂度。可以根据实际情况优化，例子中为选取标准中间值)

用途：collections.sort() 底层就是用了优化后的快速排序法

/**
	 * 查找出中轴（默认是最低位low）的在numbers数组排序后所在位置
	 *
	 * @param array 待查找数组
	 * @param low   开始位置
	 * @param high  结束位置
	 * @return 中轴所在位置
	 */
	static int getMiddle(int[] array, int low, int high) {
		//固定的切分方式
		int key = array[low];
		while (low < high) {
			//从后半部分向前找
			while (array[high] >= key && high > low) {
				high--;
			}
			array[low] = array[high];
			//从前半部分向后找
			while (array[low] <= key && high > low) {
				low++;
			}
			array[high] = array[low];
		}
		array[high] = key;
		System.out.println(Arrays.toString(array));
		return high;
	}

	/**
	 *
	 * @param numbers 带排序数组
	 * @param low     开始位置
	 * @param high    结束位置(数组长度-1)
	 */
	static int[] quickSort(int[] arry, int low, int high) {
		if (low < high) {
			int middle = getMiddle(arry, low, high); //将numbers数组进行一分为二
			quickSort(arry, low, middle - 1); //对低字段表进行递归排序
			quickSort(arry, middle + 1, high); //对高字段表进行递归排序
		}
		return arry;
	}

	public static void main(String[] args) {
		int[] arry = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
		System.out.println(Arrays.toString(arry));
		System.out.println(Arrays.toString(quickSort(arry, 0, arry.length - 1)));
	}