[PGI]

Mi sono messo nei tuoi panni e ho cercato una soluzione al problema. Non che non esistano fior fior di algoritmi per fare quello che ti hanno chiesto (pare sia un grande classico dell'informatica, con i suoi Bubble Sort, Quick sort ecc.) ma il problema è per chi, come me, di studi scientifici ne ha fatti ben pochi. Un conto è leggere l'algoritmo e tradurlo in codice, un altro è farlo su due piedi.

Da feticista, mi sono cronometrato. In 1 ora e 16 minuti ho prodotto un algoritmo non ricorsivo di rara inefficenza, che però ha il pregio di essere un parto dei due o tre neuroni che ancora rimangono attivi.

Il primo problema che ho affrontato è quello di trovare in un vettore di numeri il numero minore.

in pseudo-pseudo codice, la faccenda l'ho risolta così:

intero X = vettore.primoElemento;
intero INDICE = 0;

ciclo:
  per ogni numero N nel vettore, a partire dal secondo:
  
    se X è maggiore di N  ->  INDICE = indice_di_N
fine ciclo.

dopo il ciclo, INDICE è diventato l'indice del numero più piccolo all'interno del vettore.

Con grande stupore di me stesso, ho scoperto che a questo punto i giochi erano già fatti.

Bastava rimuovere dal vettore originale il numero più piccolo ed infilarlo in coda ad un secondo vettore, che contenesse i numeri "ordinati": a questo punto infatti il vettore originale, avendo perso l'elemento più piccolo tra quelli contenuti, sarebbe stato già pronto per un nuovo passaggio alla ricerca del numero minore.

quindi, se N è il numero di elementi del vettore originale, l'algoritmo completo diventa

vettore
cache

ciclo esterno da 0 a N:
  intero X = vettore(0);
  intero indice = 0;

  ciclo interno da J = 1 a J = vettore.dimensione:
    intero Y = vettore(J);
    se (X > Y) -> indice = J; X = Y;
  fine ciclo interno
  
  vettore.rimuovi(elemento_indice);
  cache.aggiungi(elemento_eliminato);
fine ciclo esterno.

In Java la cosa assume la seguente forma:

Vector<Integer> vettore = //vettore con i numeri
Vector<Integer> cache = new Vector<Integer>();
int numLoops = vettore.size();
for(int loop = 0; loop < numLoops; loop++) {
	int size = vettore.size();
	int valore = vettore.get(0);
	int indiceMinore = 0;

	for(int i = 1; i < size; i++) {
		int valore2 = vettore.get(i);
		if(valore > valore2) {
			valore = valore2;
			indiceMinore = i;
		}
	}
	cache.add(vettore.remove(indiceMinore));
}

In VBasic sono certo che i vettori abbiano un comportamento analogo: in Java "get(int)" restituisce (ma non rimuove) il valore dell'elemento di indice "int", "remove(int)" restituisce e rimuove l'elemento di indice "int", "add(valore)" aggiunge in coda al vettore "valore".

Se cerchi in rete per "Bubble Sort" o "Quick Sort" trovi la soluzione "reale" al problema.

Ciao.