El orden de cada ajuste de montón en la clasificación de montón

La ordenación del montón (ordenación del montón) es una mejora de la ordenación por selección simple. El enfoque de la mejora es: cómo reducir el número de comparaciones de registros. La selección de selección simple selecciona solo el registro más pequeño en un pase de clasificación, y no guarda los resultados de comparación de un pase, por lo que los tiempos de comparación de los registros son más. Al seleccionar el registro más pequeño, la ordenación del montón también encuentra registros más pequeños, reduciendo el número de comparaciones seleccionadas, mejorando así la eficiencia de toda la ordenación. La idea básica del algoritmo de ordenación del montón es la siguiente:
primero construya la secuencia que se clasificará en un montón raíz grande, es decir, seleccione el registro más grande de todos en el montón, elimínelo del montón y ajuste los registros restantes en un montón, de modo que Encontré el siguiente registro más pequeño, y así sucesivamente, hasta que solo hubo un registro en el montón.
Ahora espero calcular el orden del montón después de cada ajuste de montón (incluida la construcción del montón inicial) durante el proceso de clasificación de montón pequeño a grande.

[Forma de entrada]
Un entero N en la primera línea, N enteros en la segunda línea, sin ordenar. 0 <N <= 100
[Forma de salida] Se
emiten N líneas de salida. La fila i-ésima corresponde al orden de los enteros N-i + 1 después del ajuste de la pila i-ésima.
[Entrada de muestra]
5
2 3 1 5 4
[Salida de muestra]
5 4 1 3 2
4 3 1 2
3 2 1
2 1
1

Análisis: La
ordenación del montón utiliza la naturaleza de un árbol binario completo para construir un montón de raíz grande (montón de raíz pequeño), colocar el nodo raíz más grande (más pequeño) y luego intercambiar el nodo raíz con el último nodo. La
esencia es utilizar la construcción repetida del montón de raíz grande (pequeño Método de montón dinámico), encuentre el valor máximo (mínimo) y luego ordénelo intercambiando con el último nodo

Función para construir montón

void adjust(int arr[],int n,int i)
{
    int left=i*2+1;//下标为i的左孩子
    int right=i*2+2;//下标为i的右孩子
    int maxi = i;
    if(left<n&&arr[left]>arr[maxi])
        maxi=left;
    if(right<n&&arr[right]>arr[maxi])
        maxi=right;
    if(maxi!=i)//当下标为i 的结点不是它和它孩子节点中最大数时
    {
        swap(arr[maxi],arr[i]);
        adjust(arr,n,maxi);
    }
}

Función para ordenar el montón de salida

void heapSort(int arr[],int n)
{
    for(int i=n/2-1;i>=0;i--)//从第一个非叶子结点开始
    {
        adjust(arr,n,i);//初始建堆
    }
    for(int i =0;i<n;i++)
    {
        cout<<arr[i]<<" ";
    }
    cout<<endl;
    for(int i=n-1,j=n-1;i>=1;i--,j--)//经过初始建堆后 还需n-1次建堆
    //每次最大的在树的根节点上
    {
        swap(arr[0],arr[i]);//把根节点和最后一个结点交换
        adjust(arr,i,0);//继续进行排堆 从下标为0的结点开始 对剩下的i个进行堆排序
        for(int i=0;i<j;i++)
        {
            cout<<arr[i]<<" ";//输出堆排序后每次堆调整后的次序
        }
        cout<<endl;
    }
}

Función principal

int main()
{
    int n;
    cin>>n;
    int arr[n];
    for(int i=0;i<n;i++)
    {
        cin>>arr[i];
    }
    heapSort(arr,n);
}

Debajo hay un poco de blanco. Si hay un lugar inapropiado, corrígeme.