#include <iostream>
#include <conio.h>

using namespace std;

int main() {
    int numeros[] = {3, 2, 1, 5, 4};
    int n = 5; // Tamaño del array

    // Variables para el algoritmo
    int low = 0;
    int high = n - 1;
    int stack[100]; // Pilas para manejar índices
    int top = -1;   // Apunta al último elemento en la pila
    int temp, pivot, i, j;

    // Inicializar la pila con los límites del array
    stack[++top] = low;
    stack[++top] = high;

    // Algoritmo de QuickSort usando una pila
    while (top >= 0) {
        // Obtener el límite del subarray
        high = stack[top--];
        low = stack[top--];

        // Eligiendo el pivote (último elemento del subarray)
        pivot = numeros[high];
        i = low - 1;

        for (j = low; j < high; j++) {
            if (numeros[j] < pivot) {
                i++;
                // Intercambiar elementos
                temp = numeros[i];
                numeros[i] = numeros[j];
                numeros[j] = temp;
            }
        }

        // Intercambiar el pivote con el elemento en la posición correcta
        temp = numeros[i + 1];
        numeros[i + 1] = numeros[high];
        numeros[high] = temp;

        int pi = i + 1;

        // Apilar las sublistas para procesarlas más tarde
        if (pi - 1 > low) {
            stack[++top] = low;
            stack[++top] = pi - 1;
        }
        if (pi + 1 < high) {
            stack[++top] = pi + 1;
            stack[++top] = high;
        }
    }

    // Imprimir array ordenado en orden ascendente
    cout << "Orden Ascendente: \n";
    for (int i = 0; i < n; i++) {
        cout << numeros[i] << " ";
    }
    cout << endl;

    // Imprimir array ordenado en orden descendente
    cout << "Orden Descendente: \n";
    for (int i = n - 1; i >= 0; i--) {
        cout << numeros[i] << " ";
    }
    cout << endl;

    getch();
    return 0;
}

Explicación del Código

  1. Inicialización:

    • Se define un array stack para manejar los índices de los subarrays.
    • Se inicializan low y high para definir los límites del array que se está procesando.

  2. Algoritmo de QuickSort:

    • Se usa una pila para realizar un recorrido iterativo del algoritmo QuickSort, evitando la recursión.
    • El pivote se elige como el último elemento del subarray.
    • Se particiona el array de manera que todos los elementos menores que el pivote estén a su izquierda y los mayores a su derecha.
    • Luego se intercambia el pivote con el elemento en la posición correcta.
    • Las sublistas a la izquierda y derecha del pivote se apilan para ser procesadas más tarde.

  3. Impresión de Resultados:

    • Después de ordenar el array, se imprime en orden ascendente y descendente.