[C/C++]-[Function] Organizando Arrays, explicada

Assunto: [C/C++]-[Function] Organizando Arrays, explicada Qui Jan 27 2011, 17:38

Esse é o coidgo completo, copie e cole no em um arquivo, lembrando de passar as definiçoes para um header. Este é o codigo para uso. Para ler e entender o codigo, há uma versao propria mais abaixo.

Código:: #include
#include

#ifndef ArrayOrganize_H
#define ArrayOrganize_H
void ArrayOrganizeAsc (int *panArray, int nArrayLenght);
void ArrayOrganizeDesc (int *panArray, int nArrayLenght);

void ArrayOrganizeAsc (char *pachArray, int nArrayLenght);
void ArrayOrganizeDesc (char *pachArray, int nArrayLenght);

void ArrayOrganizeAsc (float *pafArray, int nArrayLenght);
void ArrayOrganizeDesc (float *pafArray, int nArrayLenght);
#endif

void ArrayOrganizeAsc (int *panArray, int nArrayLenght)
{
if (!panArray || !nArrayLenght)
return;

for (int nStartIndex = 0; nStartIndex < nArrayLenght; nStartIndex++)
{
int nSwapIndex = nStartIndex;
for (int iii=nStartIndex+1; iii < nArrayLenght; iii++)
//For loop that sets nSwapIndex as the min of the Array
{
if ( panArray[nSwapIndex] > panArray[iii] )
{nSwapIndex = iii;}
}
swap( panArray[nSwapIndex], panArray[nStartIndex] );
}
}

void ArrayOrganizeDesc (int *panArray, int nArrayLenght)
{
if (!panArray || !nArrayLenght)
return;

for (int nStartIndex = 0; nStartIndex < nArrayLenght; nStartIndex++)
{
int nSwapIndex = nStartIndex;
for (int iii=nStartIndex+1; iii < nArrayLenght; iii++)
//For loop that sets nSwapIndex as the min of the Array
{
if ( panArray[nSwapIndex] < panArray[iii] )
{nSwapIndex = iii;}
}
swap( panArray[nSwapIndex], panArray[nStartIndex] );
}
}

void ArrayOrganizeAsc (char *pachArray, int nArrayLenght)
{
if (!pachArray || !nArrayLenght)
return;

for (int nStartIndex = 0; nStartIndex < nArrayLenght; nStartIndex++)
{
int nSwapIndex = nStartIndex;
for (int iii=nStartIndex+1; iii < nArrayLenght; iii++)
//For loop that sets nSwapIndex as the min of the Array
{
if ( pachArray[nSwapIndex] > pachArray[iii] )
{nSwapIndex = iii;}
}
swap( pachArray[nSwapIndex], pachArray[nStartIndex] );
}
}

void ArrayOrganizeDesc (char *pachArray, int nArrayLenght)
{
if (!pachArray || !nArrayLenght)
return;

for (int nStartIndex = 0; nStartIndex < nArrayLenght; nStartIndex++)
{
int nSwapIndex = nStartIndex;
for (int iii=nStartIndex+1; iii < nArrayLenght; iii++)
//For loop that sets nSwapIndex as the min of the Array
{
if ( pachArray[nSwapIndex] < pachArray[iii] )
{nSwapIndex = iii;}
}
swap( pachArray[nSwapIndex], pachArray[nStartIndex] );
}
}
void ArrayOrganizeAsc (float *pafArray, int nArrayLenght)
{
if (!pafArray || !nArrayLenght)
return;

for (int nStartIndex = 0; nStartIndex < nArrayLenght; nStartIndex++)
{
int nSwapIndex = nStartIndex;
for (int iii=nStartIndex+1; iii < nArrayLenght; iii++)
//For loop that sets nSwapIndex as the min of the Array
{
if ( pafArray[nSwapIndex] > pafArray[iii] )
{nSwapIndex = iii;}
}
swap( pafArray[nSwapIndex], pafArray[nStartIndex] );
}
}

void ArrayOrganizeDesc (float *pafArray, int nArrayLenght)
{
if (!pafArray || !nArrayLenght)
return;

for (int nStartIndex = 0; nStartIndex < nArrayLenght; nStartIndex++)
{
int nSwapIndex = nStartIndex;
for (int iii=nStartIndex+1; iii < nArrayLenght; iii++)
//For loop that sets nSwapIndex as the min of the Array
{
if ( pafArray[nSwapIndex] < pafArray[iii] )
{nSwapIndex = iii;}
}
swap( pafArray[nSwapIndex], pafArray[nStartIndex] );
}
}

Para usar, a formula eh "ArrayOrganizeAsc para ascendente ou Desc para descendente" ( "ArrayEmQuestao", "TamanhoDoArray" );

Agora, vamos analizar essa funçao e entende-la melhor!
Tudo começa com um if para validar se ambos os parametros foram declarados, mas vamos deixalo de lado.
Usamos um for loop para ter acesso aos varios elementos de um array

Código:: for (int nStartIndex = 0; nStartIndex < nArrayLenght; nStartIndex++)
//nStartIndex eh o primeiro elemento que sera afetado a cada loop
//nArrayLenght eh o nome do parametro de tamanho do array
{
//Funcao do array aqui
}

Agora precisaremos de outro loop, interno, para achar o menor numero a frente do atual. Isso eh feito assim porque cada vez que o primeiro loop acaba, um o menor elemento entre os restantes fica atras.
Mas para isso usamos uma variavel para guardar o minimo e soh depois de checar todos para qual numero menor eh menor entre si, e quando o segundo loop terminar essa variavel seria esquecida, portanto precismos que ela seja declarada externamente ao segundo loop para evitar esse efeito.

Código:: or (int nStartIndex = 0; nStartIndex < nArrayLenght; nStartIndex++)
{
int nSwapIndex = nStartIndex;
//nSwapIndex começa como igual a nStartIndex, e apenas sera mudada se algum numero for menor do que o contido em nStartIndex
for (int iii=nStartIndex+1; iii < nArrayLenght; iii++)
//iii = nStartIndex+1 porque nao eh nessesario checar se o numero atual eh menor do que ele mesmo.
{
//Segundo Loop
}
}

Agora, precisaremos mudar nSwapIndex apenas se o valor do array em iii for menor que o no nSwapIndex original, mas ainda nao qremos fazer a mudança no Array em si, isso sera feito apenas quando o minimo ente todos a frente for achado

Código:: for (int nStartIndex = 0; nStartIndex < nArrayLenght; nStartIndex++)
{
int nSwapIndex = nStartIndex;
for (int iii=nStartIndex+1; iii < nArrayLenght; iii++)
{
//panArray é o nome do array na declaraçao, pelo menos na de Int
if ( panArray[nSwapIndex] > panArray[iii] ) //Se o array em iii for menor
{nSwapIndex = iii;}//Muda as coordenadas de nSwapIndex para as do atual iii
}
}

Feito isso, temos uma funçao que pega uma coordenada, e retorna a coordenada a frente com menor valor entre todas. Mas ainda nao alteramos o array em si.

Para fazer uma troca, poderiamos facilmente criar um pequeno codigo com esse objetivo, porem o header #include jah contem essa funçao, e prefiro usa-la

Código:: or (int nStartIndex = 0; nStartIndex < nArrayLenght; nStartIndex++)
{
int nSwapIndex = nStartIndex;
for (int iii=nStartIndex+1; iii < nArrayLenght; iii++)
{
if ( panArray[nSwapIndex] > panArray[iii] )
{nSwapIndex = iii;}
}
//Essa funçao trocara os valores atual da coordenada e o minimo valor a frente
swap( panArray[nSwapIndex], panArray[nStartIndex] );
}

Agora, cada vez que o loop primario rodar, o valor da coordenada atual sera trocado com o maior valor a frente.
Quando o loop tiver rodado, o valor menor atras nao sera mais contado, portanto nao ficaremos presos a um unico valor para troca.
Quando o loop tiver rodado todos os elementos de um array, ele tera ficado em ordem ascendente.

Para fazer o contrario, simplesmente troca-se o sinal no IF!