1 Orden de inserción
Ideas:
(1) Divida la matriz en "intervalo ordenado" y "rango a ordenar", utilice límite para identificar estos dos intervalos, límite es la primera posición del intervalo a ordenar;
(2) Dividir la primera posición del intervalo a ordenar Un elemento (es decir, el elemento en la posición de la marca de límite) se compara con el elemento en el rango.
public static void insertSort(int[] arr) {
// 划分“已排区间” 和 “待排区间”
int bound = 1;
// 用于控制边界值向后走
// 即，待排区间往后缩小
for (; bound < arr.length; bound ++) {
int v = arr[bound];
// 待排区间的前一个元素
int cur = bound - 1;
// 已排区间从后往前遍历
// 寻找合适的位置插入 arr[bound]
for (; cur >= 0; cur --) {
if (arr[cur] > v) {
// 元素向后移动一位
arr[cur + 1] = arr[cur];
} else {
break;
}
}
// 找到合适位置，插入
arr[cur + 1] = v;
}
}Complejidad temporal: O (N 2 )
Complejidad espacial: O (1)
Clasificación estable
2 Tipo de colina
Idea:
especifique un intervalo (secuencia de intervalo Hill, longitud / 2, longitud / 4, longitud / 8… 1), divida la matriz en varios grupos, ordene cada grupo por separado y luego ajuste los cambios de agrupación para hacer que la matriz cambie gradualmente. ordenado. Se pueden construir dos métodos: el primer método construye el coeficiente de agrupamiento y el segundo método utiliza la brecha anterior como base para la inserción del grupo.
Hill sort es una versión mejorada de la ordenación por inserción, por lo que su implementación de código y su idea son muy similares a la ordenación por inserción.
public static void shellSort(int[] arr) {
int gap = arr.length / 2;
while (gap >= 1) {
_shellSort(arr,gap);
gap = gap / 2;
}
}
public static void _shellSort(int[] arr,int gap) {
int bound = gap;
for (; bound < arr.length ; bound++) {
int v = arr[bound];
int cur = bound - gap;
for (; cur >= 0 ; cur = cur - gap) {
if (arr[cur] > v) {
arr[cur + gap] = arr[cur];
} else {
break;
}
}
arr[cur + gap] = v;
}
}Complejidad temporal: O (N 2 ) => O (N 1.3 )
Complejidad espacial: O (1)
ordenación inestable
3 Seleccione ordenar
(1) Divida la matriz en dos intervalos, el intervalo a ordenar y el intervalo ya ordenado, pero tenga en cuenta que aquí es diferente de la ordenación por inserción,El límite de clasificación de inserción puede ser cualquier elemento y el límite de clasificación de selección debe comenzar desde 0. Debido a que la clasificación por selección seleccionará el valor más pequeño y lo colocará al final del intervalo clasificado al seleccionar y ordenar en la selección posterior. Si elige al azar al principio, los elementos subsiguientes pueden no ser más grandes que este elemento. Asegúrese de que el El primer elemento seleccionado es el más pequeño de la matriz.
(2) Recorra el intervalo que se va a organizar, encuentre el elemento más pequeño tocando un anillo y use la primera posición del intervalo que se va a organizar como el anillo.
public static void selectOrder(int[] arr) {
int bound = 0;
for (;bound < arr.length; bound ++) {
for (int cur = bound + 1; cur < arr.length; cur++) {
if (arr[cur] < arr[bound]) {
swap(arr,cur,bound);
}
}
}
}
public static void swap (int[] arr,int cur,int bound) {
int tmp = arr[cur];
arr[bound] = arr[cur];
arr[cur] = tmp;
}Complejidad temporal: O (N 2 )
Complejidad espacial: O (1)
Clasificación inestable
4 clasificación de montón
(1) Cree un
montón grande con la matriz actual; (2) Elimine el elemento superior del montón, es decir, intercambie el elemento superior y el último elemento, y luego elimine el último elemento del montón. Tenga en cuenta que no es eliminado de la matriz, el valor máximo es Se coloca al final de la matriz;
(3) Ajuste hacia abajo desde el elemento 0 para convertirlo en un montón nuevamente;
(4) Cambie el primer elemento y el último elemento del montón nuevamente, y el último elemento en este momento es El penúltimo elemento de la matriz coloca el segundo número más grande en la penúltima posición de la matriz, y así sucesivamente, en bucle continuo.
public static void heapSort(int[] arr) {
createHeap(arr);
int heapSize = arr.length;
for (int i = 0; i < arr.length; i++) {
// 交换堆上的 第一个和最后一个元素
// 注意堆的最后一个元素并不是每次都是数组的最后一个元素
swap(arr,0,heapSize - 1);
// 删除堆的最后一个元素，但是它还存在在数组中
heapSize --;
// 只用调整一次，因为其本身已经是堆，只是交换后的第一个元素需要调整
shiftDown(arr,heapSize,0);
}
}
private static void createHeap(int[] arr) {
for (int i = ((arr.length - 1) - 1 ) / 2; i >= 0 ; i--) {
shiftDown(arr,arr.length,i);
}
}
public static void shiftDown(int[] arr,int size,int index) {
int parent = index;
int child = 2 * parent + 1;
while (child < size) {
if (child + 1 < size && arr[child + 1] > arr[child]) {
child = child + 1;
}
if (arr[child] > arr[parent]) {
swap(arr,child,parent);
}
parent = child;
child = 2 * parent + 1;
}
}Complejidad temporal: O (Nlog N )
Complejidad espacial: O (1)
Clasificación inestable
5 Clasificación de burbujas
Idea:
Compare dos elementos adyacentes, si no cumplen con el orden ascendente, cámbielos. Si se recorre de atrás hacia adelante, después de un recorrido, el valor máximo llegará al final; si se recorre de adelante hacia atrás, el valor mínimo será estar después de una travesía. Llegando al final.
public static void bubbleSort(int[] arr) {
for (int bound = 0; bound < arr.length; bound++) {
for (int cur = arr.length - 1; cur > bound ; cur--) {
if (arr[cur - 1] > arr[cur]) {
swap(arr,cur - 1,cur);
}
}
}
}Complejidad temporal: O (N 2 )
Complejidad espacial: O (1)
Clasificación estable
6 Clasificación rápida
Ideas:
(1) Seleccione un "valor de referencia" en la matriz a ordenar y luego organice la matriz en: el lado izquierdo es más pequeño que el valor de referencia y el lado derecho es más grande que el valor de referencia;
(2) Utilice los subíndices izquierdo y derecho para ir desde ambos lados del recorrido medio.
public static void quickSort(int[] arr) {
_quickSort(arr,0,arr.length - 1);
}
public static void _quickSort(int[] arr,int left,int right) {
if (left >= right) {
return;
}
// index 表示基准值所在的位置
int index = partition(arr,left,right);
_quickSort(arr,left,index - 1);
_quickSort(arr,index + 1,right);
}
public static int partition(int[] arr,int left,int right) {
// v 用来存放基准值
int v = arr[right];
int l = left;
int r = right;
while (l < r) {
// 找到大于基准值的元素的位置
while (l < r && arr[l] <= v) {
l ++;
}
// 找到小于基准值的元素的位置
while (l < r && arr[r] >= v) {
r --;
}
// 交换两个位置的元素
swap(arr,l,r);
}
// 当 l == r 时，循环进不去
// 交换 l位置 和 right位置的元素，right 为基准值的位置
swap(arr,l,right);
return l;
}Complejidad temporal: O (NlogN) Peor O (N)
Complejidad espacial: O (logN) Peor O (N) Depende de la profundidad de la recursividad
Clasificación inestable
Métodos de optimización para una clasificación rápida:
1. Tome el medio de los tres números: es decir, tome tres números, el primer número, el último número y el número del medio de la matriz, el que sea el número del medio;
2. Cuando el intervalo para procesarse Cuando es relativamente pequeño, la recursividad no continúa, y la ordenación por inserción se realiza directamente en el intervalo;
3. Cuando la profundidad de recursión alcanza una cierta profundidad y el intervalo actual a procesar aún es relativamente grande, también puede usar clasificación de montón