Ir ao conteúdo
  • Cadastre-se
Cambalinho

Como ordenar 1 lista\vector alfabecticamente?

Recommended Posts

Existem várias técnicas para isso mas a mais simples que conheço é assim:

 

1º Armazena a primeira posição do vetor em uma variavel "menorValor"

2º Agora você faz uma repetição que percorre todas posições do vetor comparando se o valor na posição é menor que o da variável "menorValor"

3º Se for menor você troque os valores (usando uma variavel auxiliar)

4º Se não for menor você continua procurando pelo resto do vetor

5º Ao final da primeira repetição você terá encontrado o menor valor de todo vetor, troque ele de posição com a primeira posição do vetor e faça outra repetição só que desta vez da 2º posição para frente, ignorando o menor valor já encontrado que está na posição correta. Assim você encontrará o segundo menor valor. Repetir até o vetor acabar.

 

Então são duas repetições, uma dentro da outra, uma encontrará o menor valor e a segunda repetirá a primeira até todo o vetor ter sido percorrido. Para ordenar por ordem descrescente é só procurar pelo maior valor e por ordem crescente é só procurar pelo menor valor.

Espero que consiga entender.

Compartilhar este post


Link para o post
Compartilhar em outros sites

 # include <stdio.h>
int main(){
        int i, v[5], maior,menor;
        for (i=0; i<5; ++i){         //Se faz um for só para receber o numero
        printf("%do numero:  ",i+1);
        scanf("%d",&v);
        }
        maior=v[1];   //A variavel maior sempre vai receber o numero da primeira posição
        menor=v[1];   //A variavel menor sempre vai receber o numero da primeira posição

        for(i=0; i<5; ++i){   //Faz-se outro for para percorrer as posições do vetor comparando cada um

        if (v>maior) maior=v; //Na primeira volta do laço sempre não entrara no if, pois v=maior=menor
        if (v<menor) menor=v; //A comparação (entrada no if) só começa na segunda volta do laço
        }
        printf("Maior: %d: ",maior);
        printf("Menor: %d",menor);
}
 

adicionado 21 minutos depois

ops perdão, não li corretamente a pergunta!! kk
 

Compartilhar este post


Link para o post
Compartilhar em outros sites

listas normais... array\vectores

adicionado 47 minutos depois

yah estou a fazer 1 grande confusao para entender isto :(

int elementos[]={4,7,2,1,6,0,5,8,3,9};
            for(int i=0;i<10;i++)
            {
                int elemento=elementos[i];
                for(int a=0;a<10;a++)
                {
                    if(elemento>elementos[a])
                    {
                        elementos[a]=elemento;
                    }
                }
            }
            
            //print the results:
            for(int i=0;i<10;i++)
            {
                DebugText(to_string(elementos[i]));
            }

saída:

Citação

9
9
9
9
9
9
9
9
9
9

ao menos sao 10 :P
mas agora aserio: eu entendo que eu esteja a fazer 1 enorme confusao. porque é mesmo confuso, por agora. com o mesmo codigo, alguem me pode explicar o que me esta a falhar?(talvez assim eu perceba melhor)

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Cambalinho Com a comparação "if(elemento>elementos[a])" você estará ordenando da forma decrescente. O problema ocorre na hora de realizar a troca, que você não faz, apenas substitui.

Acredito que o correto seria algo parecido com isto:

if(elemento>elementos[a])

{

    int auxiliar;

    auxiliar = elemento[a];

    elementos[a]=elemento;

    elemento=auxiliar;

}

Percebeu que eu troquei o valor da variável contendo o menor valor com o vetor e não apenas substituí um pelo outro? Você também não está controlando o início da posição do segundo for.

Acho que o seguinte código "for(int a=0;a<10;a++)" deveria ser trocado por "for(int a=0+i;a<10;a++)", eu incluí o contador i do primeiro for para toda vez que for contar ele começar a partir da posição seguinte...

Ta difícil explicar, eu sei como tem de ser só não consigo por em palavras.

Editado por grievous
  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
#include <iostream>
using namespace std;

int main () {

    int v[] = {4, 7, 2, 1, 6, 0, 5, 8, 3, 9};
    int aux;
    
    for ( int i = 0; i < 10-1; i++ ) { //-1 é importante       
        for ( int a = i+1; a < 10; a++ ) {
            if ( v[i] > v[a] ){
                aux = v[i];
                v[i] = v[a];
                v[a] = aux;
            }
        }
    }
    
    //print the results:
    for ( int i = 0; i < 10; i++ ) {
        cout << v[i] << ", "; 
    }
    
    
    
    
    cin.ignore();
    return 0;
}

 

Eu acho que a forma correta de organizar mais efetiva seria assim. Dessa forma você evita comparações como elemento[1] com elemento[1] que é exatamente a mesma coisa, não há cabimento fazer isso, por isso inicializamos a com i+1.
 

E na primeira passada o quando o laço interno completar todas as comparações com a primeira casinha do vetor o menor valor ja estará contido na v[0] então é errado,  voltar a comparar v[0] com outros valores, inicializando i com zero e a com zero sempre nas primeiras iterações você compara
v0 com v0 (errado... nunca comparar com a mesma casa)
v0 com v1 (ok... é a primeira vez)
v0 com v2

v0 com v3

v0 com v4

v0 com v5

v0 com v6

v0 com v7

v0 com v8
v0 com v9

dai como você volta a inicializar novamente ao índice 'a', o valor de zero(a=0) acontece isso:

v1 com v0 (isso já foi feito no conjunto de iteração anterior, voltamos a comparar coisas que ja foram resolvidas Errado)
v1 com v1
v1 com v2

v1 com v3

v1 com v4

v1 com v5

v1 com v6

v1 com v7

v1 com v8
v1 com v9

v2 com v0 (isso já foi feito no 1º conjunto de iteração, ja comparamos anteriormente v0 com v2. Ineficiente!)
v2 com v1
v2 com v2
v2 com v3
v2 com v4
v2 com v5
v2 com v6
v2 com v7
v2 com v8
v2 com v9

v3 com v0 (mesma coisa... v0 ja foi comparado com v3) =/
v3 com v1
v3 com v2
v3 com v3
v3 com v4
v3 com v5
v3 com v6
v3 com v7
v3 com v8
v3 com v9

E isso se repetirá até o fim, você voltará a refazer comparações desnecessárias.

porém com minha solução a coisa fica assim:
v0 com v0 Eliminamos uma iteração ao não comparar v0 com v 0 novamente. Efetividade++
v0 com v1 ( a=i+1 )
v0 com v2
v0 com v3
v0 com v4
v0 com v5
v0 com v6
v0 com v7
v0 com v8
v0 com v9

v1 com v0 Eliminamos uma iteração ao não comparar v0 com v 0 novamente. Efetividade++
v1 com v1 (Eliminado da iteração, não devemos comparar v1 com v1)
v1 com v2 ( a=i+1 )
v1 com v3
v1 com v4
v1 com v5
v1 com v6
v1 com v7
v1 com v8
v1 com v9

v2 com v0 Eliminamos uma iteração ao não comparar v0 com v 0 novamente. Efetividade++
v2 com v1 (Eliminado da iteração, não devemos comparar v1 com v1)
v2 com v2 (Eliminado da iteração, não devemos comparar v2 com v1)
v2 com v3 ( a=i+1 )
v2 com v4
v2 com v5
v2 com v6
v2 com v7
v2 com v8
v2 com v9

ou seja acontece isso:
v3 com v4
v3 com v5
v3 com v6
v3 com v7
v3 com v8
v3 com v9

v4 com v5
v4 com v6
v4 com v7
v4 com v8
v4 com v9

 

v5 com v6
v5 com v7
v5 com v8
v5 com v9


v6 com v7
v6 com v8
v6 com v9


v7 com v8
v7 com v9


v8 com v9

v9 com com o resto não é necessário, v9 já foi comparado com outras casinhas em todas as iterações anteriores, por isso i<10-1. Eliminado!

Como você pode ver esse algoritmo é bem melhor e bem mais efetivo no que em rendimento se refere. Basta você por -1 no laço externo, e como inicializador interno você usa o valor do índice externo +1.

Sei que não tem nada que ver com sua consulta, porém acho mais correto essa forma de fazer, a outra é ineficiente. Esse algoritmo também funciona com matrizes:
 

#include <iostream>
using namespace std;

int main () {

    int m[10][10] = {
        {4, 7, 2, 1, 6, 0, 5, 8, 3, 9},
        {4, 7, 2, 1, 6, 0, 5, 8, 3, 9},
        {4, 7, 2, 1, 6, 0, 5, 8, 3, 9},
        {4, 7, 2, 1, 6, 0, 5, 8, 3, 9},
        {4, 7, 2, 1, 6, 0, 5, 8, 3, 9},
        {4, 7, 2, 1, 6, 0, 5, 8, 3, 9},
        {4, 7, 2, 1, 6, 0, 5, 8, 3, 9},
        {4, 7, 2, 1, 6, 0, 5, 8, 3, 9},
        {4, 7, 2, 1, 6, 0, 5, 8, 3, 9},
        {4, 7, 2, 1, 6, 0, 5, 8, 3, 9}
    };
        
    int aux;
    
    for ( int i = 0; i < (10*10)-1; i++ ) {        
        for ( int a = i+1; a < (10*10); a++ ) {
            if ( m[0][i] > m[0][a] ){
                aux = m[0][i];
                m[0][i] = m[0][a];
                m[0][a] = aux;
            }
        }
    }
    
    //print the results:
    for ( int i = 0; i < (10*10); i++ ) {
        cout << m[0][i] << ", "; 
    }
    
    
    
    
    cin.ignore();
    return 0;
}


O segredo é tratar a matriz como um vetor aproveitando a estrutura da memória =). Por isso C/C++ é bem melhor que outros linguagens, isso dói muito aos javeiros HAHAHAH, certamente ao ver isso vão chorar e muito. Tratar matrizes como vetor tem seu rendimento muito mais incrementado que trata-lo como matriz, porém só em C/C++ >_<, certamente todos os programas de edição de foto devem fazer isso com suas imagens.



 

 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×