[Ajuda c#] Ordenar listapessoas com metodo de ordenacao

[Micael Reis]

Boas!!

private void Swap(int firstIndex, int secondIndex)
{
object temp = this[firstIndex];
this[firstIndex] = this[secondIndex];
this[secondIndex] = temp;
}


// Algoritmo de ordenação Bubble Sort
public void BubbleSort()
{
bool trocas = true;
for (int i = 0; i < this.Count - 1 && trocas==true; i++)
{
trocas = false;
for (int j = this.Count - 1; j > i; j--)
{
IComparable leftE = (IComparable)this[j - 1];

// Se o elemento da esquerda é maior que o elemento da direita!
if (leftE.CompareTo((IComparable)this[j]) > 0)
{
Swap(j - 1, j);
trocas = true;
}
}
}
}


// Algoritmo de ordenação Selection Sort
public void SelectionSort()
{
// ciclo exterior - cada passagem ordena um elemento
int index, toIndex, indexOfSmallest;

for (index = 0; index < this.Count - 1; index++)
{
indexOfSmallest = index;

// ciclo interior - procura o menor elemento
for (toIndex = index + 1; toIndex < this.Count; toIndex++)
{
IComparable auxTo = (IComparable)this[toIndex];

if (auxTo.CompareTo(this[indexOfSmallest]) < 0)
indexOfSmallest = toIndex;
}
Swap(indexOfSmallest, index);
}
}

// Algoritmo de ordenação Insertion Sort
public void InsertionSort()
{
int index, auxIndex;
object temp;

// ciclo exterior - move a posição a testar
for (index = 1; index < this.Count; index++)
{
// se o elemento na posição index for menor que o elemento da sua esquerda
IComparable auxL = (IComparable)this[index - 1];

if (auxL.CompareTo( this[index]) > 0)
{
// guarda-se o elemento à parte
temp = this[index];
auxIndex = index;

// ciclo interior - move os outros elementos para a direita
IComparable other = null;
do
{
this[auxIndex] = this[auxIndex - 1];
auxIndex--;
if (auxIndex != 0)
other = (IComparable)this[auxIndex - 1];
} while (auxIndex > 0 && other.CompareTo(temp) > 0);

// insere o elemento na posição deixada livre
this[auxIndex] = temp;
}
}
}

// Métodos necessários ao algoritmo de ordenação Merge Sort
// Merge, permite fundir duas partes ordenadas de um vector
private void Merge(int fromLeft, int fromRight, int toIndex)
{
// Cria array auxiliar para copiar valores ordenadamente
SortableArray auxiliar = new SortableArray(toIndex - fromLeft + 1);

int i, j;
i = fromLeft;
j = fromRight+1;

// Copia para array auxiliar o menor valor
while (i <= fromRight && j <= toIndex)
{
IComparable auxi = (IComparable)this[i];

if (auxi.CompareTo(this[j]) <= 0)
{
auxiliar.Add(this[i]);
i++;
}
else
{
auxiliar.Add(this[j]);
j++;
}
} // ciclo while

for (; i <= fromRight; i++)
auxiliar.Add(this[i]);

for (; j <= toIndex; j++)
auxiliar.Add(this[j]);

// Repor o vector dos elementos
for ( i=fromLeft, j=0; i<=toIndex; i++, j++)
this[i] = auxiliar[j];
}


// MergeSort com argumentos - método privado
private void MergeSort(int fromIndex, int toIndex)
{
// se esta partição tiver mais do que um elemento
if (fromIndex < toIndex)
{
// calcula o ponto intermédio
int indexOfSplit = (fromIndex + toIndex) / 2;

// ordena uma parte
MergeSort(fromIndex, indexOfSplit);

// ordena a outra parte
MergeSort(indexOfSplit + 1, toIndex);

// mistura ordenadamente as duas partes já ordenadas
Merge(fromIndex, indexOfSplit, toIndex);
}
}


// Algoritmo de ordenação Merge Sort (public)
public void MergeSort()
{
MergeSort(0, this.Count - 1);
}


// Métodos associados ao algoritmo de ordenação Quick Sort
// Método de ordenação Quick Sort (private)
private void QuickSort(int fromIndex, int toIndex)
{
// se esta partição tiver mais do que um elemento
if (fromIndex < toIndex)
{
// Calcula valor pivot e garante que à sua esquerda ficam todos os valores do
// vector que lhe são menores e à sua direita ficam todos os valores que lhe são
// maiores, ainda que não necessáriamente ordenados
int indexOfSplit = Partition(fromIndex, toIndex);

// ordena uma parte
QuickSort(fromIndex, indexOfSplit - 1);
// ordena a outra parte
QuickSort(indexOfSplit, toIndex);
}
}

Penso que tens aqui tudo aquilo que precisas.

Agora só tens de adaptar à necessidade.

Cumprimentos