Demostración de varios tipos en JAVA.

Comparación temporal de varios algoritmos de clasificación

1. Clasificación de burbujas

Características: Baja eficiencia, fácil de implementar
Principio: comience desde la primera posición y luego compare los números adyacentes. Si el número anterior es mayor que el anterior, reemplaza la posición hasta el final. Cada ronda de recorrido puede atravesar el valor más grande entre los números restantes.

/**
 * 冒泡排序
 */
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. Orden de selección

Características: baja eficiencia, fácil de implementar.
Principio: cada pasada selecciona el elemento más pequeño de la secuencia a ordenar y lo coloca en la posición ordenada, y repite los pasos anteriores para los números restantes.

/**
 * 选择排序
 */
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. Ordenación por inserción

Características: baja eficiencia, fácil de implementar.
Principio: A partir del segundo número, compárelo con el número anterior uno por uno, si es menor que el número anterior, intercambie la posición con el número anterior y compare hasta la posición ordenada.

Comparado con la clasificación de burbujas: similar al burbujeo, pero después del burbujeo, el número de recorridos es cada vez menor. La ordenación por inserción es lo contrario: cuantos más números se deben recorrer, más atrás se debe recorrer.

/**
 * 插入排序
 */
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;//放入目标位置
	}
}

4. Clasificación rápida

Características: Eficiente, la complejidad del tiempo es nlogn.
Principio: adopte la idea de dividir y conquistar: primero establezca un valor intermedio, luego divida la secuencia que se va a ordenar en dos partes mayores que este valor y menores que este valor según este valor intermedio, y realice una clasificación rápida en estos dos partes respectivamente, hasta que solo quede un elemento en la secuencia (la selección del valor intermedio. Afecta la complejidad temporal de la clasificación. Se puede optimizar de acuerdo con la situación real. En el ejemplo, se selecciona el valor intermedio estándar)

Propósito: la capa inferior de collections.sort() es utilizar el método de clasificación rápida optimizado

/**
	 * 查找出中轴（默认是最低位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)));
	}