Tabla de contenido
No recursivo
proceso:
El primer paso: Complete el código de acuerdo a su propio entendimiento.
Problemas encontrados en la ordenación de burbujas:
1. ¿Cuál es el nombre de la función de clasificación de burbujas? burbuja: El significado de la burbuja. Por eso se llama Bubblesort.
2. Tengo una idea, pero los pasos generales que surgen en mi mente no son exactamente los mismos que los del libro de texto.
3. No lo he pensado, ¿cómo es que ya está en orden? Habría que pensar en utilizar una bandera para marcarlo.
Problemas con la ordenación rápida:
1. He olvidado los pasos y prácticas de clasificación rápida.
2. Hay dos formas, recursiva y no recursiva, pero tengo miedo cuando veo la palabra recursiva. Ninguno de los modos escribirá.
3. Nombre de clasificación rápida: QuickSort
4、mientras（bajo<alto && a[alto] >= pivote){--alto;}
Cuando escribí el código para una clasificación rápida, usé un pivote alto >=, pero el pivote es un valor de elemento, no un subíndice, por lo que se debe usar un pivote [alto]>=. Y, no entiendo por qué hay low<high????,
Encontré la respuesta: bajo y alto aquí son ambos subíndices, lo que evita que el pivote sea el elemento más pequeño, por lo que si un pivote [alto]>= siempre se satisface, siempre será --alto, y luego cruzará el límite, bajo< alto es para evitar cruzar el límite.
en conclusión. Distinguir subíndices y valores de elementos.
5. Olvidé devolver el valor de bajo, es decir, solo tecleé el código una vez y no pensé en qué hacer en el futuro, solo devolviendo el valor de bajo se puede configurar el pivote. a bajo de nuevo. Comienza un nuevo ciclo.
Ah, no, estoy siendo indulgente conmigo mismo. . . Aquí return low; es para lo siguiente a[low] = pivote; aquí a[low] = pivote, porque habrá una posición vacante después de la clasificación, y esta posición debe llenarse en pivote.
Abrir un nuevo bucle es cuestión de llamar a esta función más tarde. . .
6. Tenga en cuenta que los parámetros formales en la función de partición son (ElemType a[], int low, int high)
7. No puedo pensar en un método no recursivo.
La segunda vez: olvidé mucho. . . desperdiciar
Ordenamiento de burbuja
Idea: Encuentra un valor mínimo (o valor máximo) en cada viaje, y asienta su posición. Luego continúe buscando en los elementos restantes. Cada elemento encontrado determina su posición final.
El método de comparación utilizado es comparar dos elementos adyacentes, y si a[j-1]<a[j], se intercambian las posiciones. Luego, después de un pase, no es que las posiciones relativas de otros elementos permanezcan sin cambios, excepto por el valor mínimo que corre hacia la posición inicial, sino que se intercambiarán en pares siempre que cumplan con las condiciones de cambio de posición, por lo que el número Se desconoce el número de intercambios que ocurren en cada paso.
//C语言里其实并没有交换这一基本函数，只能自己敲一个。
void swap(int *a,int *b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
//冒泡排序，本次以选出最小的为例。
void BubbleSort(ElemType a[],int n) //不需要一个特殊的a[0]了，所以，0~n-1.
{
for (int i = 0; i < n-1; i++)
{
flag = false;//表示本趟冒泡排序是否发送交换
for (int j = n-1; j >= i;j--) //一趟冒泡过程
{
if (a[j] < a[j-1])
{
swap(a[j-1],a[j]);//交换
flag = true;
}
}
if(flag == false)
{
return;
/*注意到：在该for循环里，每次都将flag置为false，
若没发生交换，则不会有对flag的赋值为true。
则说明已经有序，排序完毕。
*/
}
}
}ordenación rápida
Idea: seleccione un pivote (generalmente el primer elemento). Comience desde ambos extremos y vaya al medio. Si el último es más pequeño que el valor de pivote seleccionado, cambie al frente y colóquelo en la posición del pivote, entonces habrá un espacio en la parte posterior, comience desde el uno después del pivote, seleccione Un elemento más grande que el pivote se coloca en la posición vacante, luego otro elemento se deja vacante al frente en este momento, y luego se selecciona un elemento desde atrás para colocarlo en la posición vacante... Hasta que no se pueda cambiar, coloque el pivote en la posición vacante. En este momento, los elementos a la izquierda del pivote son más pequeños que el pivote, y los elementos a la derecha son más grandes que el pivote. (La distancia desde el pivote solo representa el orden del intercambio y tiene poco que ver con el tamaño).
recursión
//划分操作：将比枢轴（pivotpos）小的元素放在枢轴左边，比枢轴大的元素放在枢轴右边。
int Partition(ElemType a[],int low,int high) //一趟划分
{
ElemType pivot = a[low];//将当前表中第一个元素设为枢轴，对表进行划分
while (low<high)//循环跳出条件
{
while (low < high && a[high] >= pivot)
{
--high;
}
a[low]=a[high];//将比枢轴小的元素移动到左端
while (low < high && a[low] <= pivot)
{
++low;
}
a[high] = a[low];//将比枢轴大的元素移动到右端
return low;
}
a[low] = pivot;
}
//快速排序·递归方式。
void QuickSort(ElemType a[],int n)
{
if (low < high) //递归跳出条件
{
int pivotpos = partition (a,low,high);
//partition（）就是划分操作，将表a[low...high]划分为满足上述条件的两个子表
QuickSort(a,low,pivotpos-1);
//这里的pivotpos= partition返回的值，也就是枢轴所在的位置，low.
//因为C语言的特性，这里的low 和 partition返回的low是两个low，指向两个不同的地方。
QuickSort(a,pivotpos+1,high);
}
}no recursivo
El algoritmo recursivo es principalmente para dividir subintervalos. Si desea implementar una clasificación rápida de forma no recursiva, solo necesita usar una pila para guardar el intervalo.
Generalmente, lo primero que viene a la mente al cambiar un programa recursivo a no recursivo es usar la pila, porque la recursividad en sí misma es un proceso de empujar la pila.