Vengo da uno sfondo di creazione di siti Web MVC e applicazioni HTML5 e di recente ho deciso di immergermi nel genere di cose che non mi è stato insegnato all'università, ovvero le cose che la maggior parte delle persone apprenderebbe in un corso di informatica.
Ho letto un libro sugli algoritmi e il primo a menzionare è l'Insertion Sort. Non l'ho capito davvero la prima volta, ma ho capito l'obiettivo, quindi ho avuto una brutta esperienza con la mia soluzione prima di leggere di più nella soluzione corretta per vedere quanto mi sono avvicinato.
Mi sono avvicinato molto, ed ecco la mia funzione in C #:
int[] SortNumbersTomsVersion(int[] numbersIn)
{
int[] output = new int[numbersIn.Count()];
for (var i = 0; i < numbersIn.Count(); i++)
{
int cardsLowerThan = 0;
for (var n = 0; n < numbersIn.Count(); n++)
{
if (numbersIn[n] < numbersIn[i])
{
cardsLowerThan++;
}
}
output[cardsLowerThan] = numbersIn[i];
}
return output;
}
Il concetto è che, comincio con un gruppo di numeri. Quindi, per ciascun numero, lo confronto con tutti gli altri numeri nell'array, per vedere quanti altri hanno un valore inferiore. Quindi prende il conteggio risultante e posiziona il numero corrente in una matrice di output in quell'indice. L'algoritmo passa attraverso tutti i numeri finché non si trovano tutti nella stessa posizione.
La mia domanda è, cosa rende l'originale migliore della mia soluzione ?
come riferimento, ecco l'algoritmo accettato al di fuori di una funzione:
int temp, k;
for (int i = 1; i < array_size; i++)
{
temp = array[i];
k = i - 1;
while (k >= 0 && array[k] > temp)
{
array[k + 1] = array[k];
k--;
}
array[k + 1] = temp;
}