Como ordenar 1 lista\vector alfabecticamente?

Cambalinho · 27 de agosto de 2016

eu tenho tido muito esta duvida simples

imagina 1 lista de elementos(vector ou array). como posso ordenar de forma crescente ou decrescente?

grievous · 27 de agosto de 2016

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.

vangodp · 27 de agosto de 2016

você se está referindo a listas da STL?

Gerivan Jose P. · 27 de agosto de 2016

# 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

Cambalinho · 27 de agosto de 2016

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
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)

grievous · 28 de agosto de 2016

@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.

vangodp · 28 de agosto de 2016

#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.