1. Este site usa cookies. Ao continuar a usar este site está a concordar com o nosso uso de cookies. Saber Mais.

Ordem decrescente

Discussão em 'Programação' iniciada por So_SiMpLe_, 25 de Fevereiro de 2008. (Respostas: 2; Visualizações: 6232)

  1. So_SiMpLe_

    So_SiMpLe_ Power Member

    Boas!
    Tou aqui com uma duvida, há uma pergunta que pede para organizar 20 numeros pedidos por orgem decrescente, mas eu nao tenho ideia de como fazer, se fossem 3 ou 4 numeros inda se usava if's mas com 20....
    Obrigado!
    Abraço!
     
  2. Baderous

    Baderous Banido

  3. S0ul

    S0ul Power Member

    Como foi dito tens várias formas, eu voute deixar aqui código do método de selecção linear:
    Código:
    #include <stdio.h>
    #include <conio.h>
    #include <stdlib.h>
    void ler_vector(int *V, int *n);
    void escrever_vector(int *V, int n);
    void sel_lin_nc(int *V, int n);
    int main()
    {
        int num, Vector[10];
     ler_vector(Vector, &num);
     printf("Vector inserido:\n");
     escrever_vector(Vector, num);
     sel_lin_nc(Vector, num);//Ordena vector por ordem decrescente
     escrever_vector(Vector, num);//Escreve vector ordenado
     return 0;
    }
    void escrever_vector(int *V, int n)
    {
     int i;
     for (i = 0; i < n; i++)
      printf("\nV[%d]= %d", i, V[i]);
    }
    void sel_lin_nc(int *V, int n) {
       int k, i, aux, i_max;
       for (k = n - 1; k > 0; k--) {
         i_max = 0;
         for (i = 1; i <= k; i++)
          if (V[i_max] >= V[i])
           i_max = i;
         aux = V[i_max]; V[i_max] = V[k]; V[k] = aux;
       }
    }
    void ler_vector(int *V, int *n) {
       int i;
       do {
         printf("\nIntroduza o nº de elementos do vector [1..10]: ");
         scanf("%d", &i);
       }while (i < 0 || i > 10);
       *n = i;
       for (i = 0; i < *n; i++) {
         printf("V[%d]= ", i);
         scanf("%d", &V[i]);
       }
    }
     
     
    
    Atenção sel_lin_nc(selecção linear não crescente) ou seja decrescente, e o modo de comparação adoptado foi de dois em dois elementos! Já agora deixo-te o link para uma página com os vários método, a partir desta mesma podes decidir qual o que achares melhor: http://paginas.fe.up.pt/~eol/AED/0506/AulasTeoricas/4vectorOrd.pdf

    Aproveito para te deixar os três algoritmos que na minha opinião são os mais importantes:
    Código:
    ALGORITMOS DE ORDENAÇÃO
    a) Selecção
    Parâmetros:
    Vector: vector com os valores a serem ordenados
    Mínimo: posição do primeiro elemento a ordenar do vector
    Máximo: posição do último elemento a ordenar do vector
    Algoritmo:
    Para i de mínimo até máximo-1 fazer
     Menor <- i
     Para j de i+1 até máximo fazer
     Se vector[j] < vector[menor]
      Menor <- j
     Fim do ciclo
     Se i != menor
      Trocar (vector, i, menor)
    Fim do ciclo
    b) BubbleSort
    Parâmetros:
    Vector: vector com os valores a serem ordenados
    Mínimo: posição do primeiro elemento a ordenar do vector
    Máximo: posição do último elemento a ordenar do vector
    Algoritmo:
    Para i de máximo-1 até mínimo fazer
     ExistiramTrocas <- falso
     Para j de mínimo até i fazer
      Se vector[j+1] < vector[j]
       Trocar (vector, j, j+1)
       ExistiramTrocas <- verdadeiro
     Fim do ciclo
     Se não ExistiramTrocas
      Terminar /* Vector ordenado */
    Fim do ciclo
    c) QuickSort
    Parâmetros:
    Vector: vector com os valores a serem ordenados
    Mínimo: posição do primeiro elemento a ordenar do vector
    Máximo: posição do ultimo elemento a ordenar do vector
    Algoritmo:
    Se (máximo-mínimo) = 1 /* Apenas dois elementos */
     Se vector[máximo] < vector[mínimo]
      Trocar (vector, mínimo, máximo)
    Senão
     Se máximo<=mínimo /* 1 ou nenhum elemento */
      Terminar /* Vector ordenado ou não pode ser ordenado */
     Senão
      Pivot <- Escolher pivot /* Tipicamente: (mínimo + máximo) /2 */
     /* garantir que vector[mínimo] <= vector[pivot] <= vector[máximo] */
     Se vector[pivot] < vector[mínimo]
      Trocar (vector, pivot, mínimo)
     Se vector[máximo] < vector[mínimo]
      Trocar(vector, máximo, mínimo)
     Se vector [máximo] < vector[pivot]
      Trocar(vector, máximo, pivot)
     i <- mínimo+1
     j <- máximo-2
     valor_pivot <- vector[pivot]
     trocar (vector, med, máximo-1) /* Colocar o pivot no fim */
     Continuar <- verdadeiro
     Repetir
      Enquanto (vector[i] < valor_pivot)
       i <- i+1
      Enquanto (valor_pivot < vector[j])
       j <- j+1
      Se i < j
       Trocar(vector, i, j)
      Senao
       Continuar <- falso
     Enquanto Continuar
     Trocar (vector, i, máximo-1) /* repôr o pivot no local correcto */
     QuickSort (vector, mínimo, i-1)
     QuickSort (vector, i+1, máximo)
    
     
    Última edição: 25 de Fevereiro de 2008

Partilhar esta Página