No podemos ordenar variables sueltas (a, b, c…) eficientemente. Necesitamos una estructura de datos que contenga una lista: un Arreglo o Vector. En PSeInt usamos Dimension lista[N] para acceder a los datos mediante índices (ej: lista[1], lista[2]).

Una sola pasada por la lista no es suficiente para ordenarla. Necesitamos repetir el proceso de revisión varias veces. Esto requiere un bucle externo (que cuenta las pasadas) y un bucle interno (que compara los elementos).

Algoritmo OrdenamientoBurbuja
    // 1. Definición de Variables y Arreglo
    Definir num, i, j, aux, cantidad Como Entero;
    // Creamos un arreglo con capacidad suficiente (ej: 50 elementos)
    Dimension num[50];
    
    // 2. Entrada de Datos (Llenado del Vector)
    Escribir "¿Cuántos números desea ordenar? (Máx 50):";
    Leer cantidad;
    
    Escribir "--- Ingrese los números ---";
    Para i <- 1 Hasta cantidad Con Paso 1 Hacer
        Escribir "Número ", i, ":";
        Leer num[i];
    FinPara
    
    // 3. PROCESO DE ORDENAMIENTO (Burbuja)
    // El ciclo externo 'i' controla las pasadas
    Para i <- 1 Hasta cantidad - 1 Con Paso 1 Hacer
        
        // El ciclo interno 'j' compara elementos adyacentes
        Para j <- 1 Hasta cantidad - 1 Con Paso 1 Hacer
            
            // Comparación: ¿El actual es mayor que el siguiente?
            Si num[j] > num[j+1] Entonces
                // INTERCAMBIO (Swap) usando variable auxiliar
                aux <- num[j];
                num[j] <- num[j+1];
                num[j+1] <- aux;
            FinSi
            
        FinPara
        
    FinPara
    
    // 4. Salida de Datos (Vector Ordenado)
    Escribir "--------------------------------";
    Escribir "LISTA ORDENADA ASCENDENTE:";
    Para i <- 1 Hasta cantidad Hacer
        Escribir num[i], " " Sin Saltar;
    FinPara
    Escribir ""; // Salto de línea final
    
FinAlgoritmo

Si tu arreglo tiene 5 elementos y haces un ciclo j Hasta 5, cuando intentes acceder a num[j+1] estarás buscando la posición 6, que no existe. PSeInt se cerrará con error.
Solución: El ciclo interno siempre debe ir hasta Cantidad - 1.

Intentar intercambiar sin aux:
A <- B (A pierde su valor original)
B <- A (B toma el valor de B)
Resultado: Ambos números terminan valiendo lo mismo. Siempre usa una variable temporal.

Algoritmo BurbujaOptimizada
    Definir vector, n, i, j, aux Como Entero;
    Dimension vector[100];
    
    // ... (Suponer carga de datos aquí) ...
    n <- 5; // Ejemplo con 5 datos
    vector[1]<-10; vector[2]<-5; vector[3]<-3; vector[4]<-8; vector[5]<-1;
    
    // OPTIMIZACIÓN:
    // En cada vuelta 'i', el número más grande ya quedó al final.
    // No necesitamos revisarlo de nuevo.
    // El ciclo interno va hasta (n - i).
    
    Para i <- 1 Hasta n-1 Hacer
        Para j <- 1 Hasta n-i Hacer
            
            Si vector[j] > vector[j+1] Entonces
                aux <- vector[j];
                vector[j] <- vector[j+1];
                vector[j+1] <- aux;
            FinSi
            
        FinPara
    FinPara
    
    Escribir "Ordenado eficientemente.";
FinAlgoritmo