Sobre algoritmos de ordenação

  • View
    2

  • Download
    0

Embed Size (px)

DESCRIPTION

Sobre algoritmos de ordenação

Text of Sobre algoritmos de ordenação

  • Bubble Sort

    No bubble sort analisado de duas em duas posies de um vetor, ordenando conforme seja determinada a lgica, crescente ou decrescente;

    A ideia percorrer o vetor diversas vezes, a cada passagem fazendo flutuar para o topo o maior elemento da sequncia.

    Vantagem

    A principal vantagem desse algoritmo que sua implementao fcil e conhecida.

    Estvel

    Desvantagem

    um mtodo simples, porm lento.

    No apresenta bons resultados quando a lista contm muitos itens.

    O fato de o arquivo j estar ordenado no ajuda a reduzir o nmero de comparaes (o custo continua quadrtico), porm o nmero de movimentaes cai para zero.

    void bubble (int vetor[],int tamanho){

    int aux;

    for (int i=0; i

  • Heap Sort

    uma rvore binria com seguintes propriedades: O valor de cada pai maior ou menor que os valores armazenados em cada filho; As folhas no ltimo nvel esto todas nas posies mais esquerda, podendo haver a falta de um elemento.

    Vantagens

    O Algoritmo heapsort apresenta o tempo mdio constante e satisfatrio (at nos piores cenrios);

    Consumo de memria baixo (mesmo em comparao com outros algoritmos de ordenao);

    Desvantagens

    No recomendado para entrada com poucos elementos, por conta do heap ser muito complexo;

    No to rpido quanto o quicksort ou outros mtodos em algumas situaes;

    O Heapsort no estvel.

    void max_heapify(int *a, int i, int n)

    {

    int j, temp;

    temp = a[i];

    j = 2*i;

    while (j a[j])

    j = j+1;

    if (temp > a[j])

    break;

    else if (temp

  • }

    a[j/2] = temp;

    return;

    }

    void heapsort(int *a, int n)

    {

    int i, temp;

    for (i = n; i >= 2; i--)

    {

    temp = a[i];

    a[i] = a[1];

    a[1] = temp;

    max_heapify(a, 1, i - 1);

    }

    }

    void build_maxheap(int *a, int n)

    {

    int i;

    for(i = n/2; i >= 1; i--)

    {

    max_heapify(a, i, n);

    }

    }

    int main()

    {

    int n, i, x;

    coutn;

    int a[20];

    for (i = 1; i

  • cout
  • Merge Sort

    Vantagens

    til para ordenao externa;

    Pior caso: O(n log n);

    Aplicaes com restrio de tempo;

    Fcil implementao.

    Desvantagens

    Utiliza memria auxiliar;

    Possui dependncia de outro vetor de tamanho idntico;

    Alto consumo de memria.

    VAZIO mergeSort(VETOR array)

    SE TAMANHO(vetor) > 1 ENTO

    NUMERICO mid, i

    mid TAMANHO(vetor) / 2)

    VETOR esquerda[mid], direita[TAMANHO(vetor) - mid]

    PARA i 0 AT TAMANHO(esquerda)

    esquerda[i] array[i]

    FIM

    PARA i 0 AT TAMANHO(direita)

    direita[i] array[i]

    FIM

    //Recurso para distribuio

    mergeSort(esquerda)

    mergeSort(direita)

    intercala(array, esquerda, direita)

    ELSE

    ESCREVA Vetor j ordenado.

    FIM

    FIM

  • VAZIO intercala(VETOR array, VETOR esquerda, VETOR direita)

    NUMRICO i1 0, i2 0, i

    PARA i 0 AT TAMANHO(array)

    // Verifica qual dos 2 valores menor e isnere no

    vetor

    SE( i1 < TAMANHO(esquerda) E i2 < TAMANHO(direita)) ENTO

    SE(esquerda[i1] < direita[i2]) ENTO

    array[i] esquerda[i1]

    i1 i1 + 1

    ELSE

    array[i] direita[i2]

    i2 i2 + 1

    FIM

    FIM

    //Caso os tamanhos dos vetores sejam diferentes, faz

    a verificao individual de cada vetor

    SENO SE (i1 < TAMANHO(esquerda)) ENTO

    array[i] esquerda[i1]

    i1 i1 + 1

    SENO

    array[i] direita[i2]

    i2 i2 + 1

    FIM

    FIM

    FIM

  • Insertion Sort

    Vantagens

    Simplicidade

    Bom desempenho em listas pequenas

    Desvantagens

    No funciona bem com listas grandes

    N passos necessrios para funcionar

    void InsertSort (int vet[]){

    int i,j,aux;

    for (i = 1; i < 5; i++){

    j = i;

    while (j > 0 && vet[j-1] > vet[j]) {

    aux = vet[j];

    vet[j] = vet[j-1];

    vet[j-1] = aux;

    j--;

    }

    }

    }

    int main(int argc, char** argv) {

    int vet[5];

    coutvet[i];

    }

    cout

  • cout
  • Bubble Sort

    Vantagens

    A principal vantagem desse algoritmo que sua implementao fcil e conhecida.

    Estvel

    Desvantagens

    um mtodo simples , porm lento .

    No apresenta bons resultados quando a lista contm muitos itens.

    O fato de o arquivo j estar ordenado no ajuda a reduzir o nmero de comparaes (o custo continua quadrtico), porm o nmero de movimentaes cai para zero.

    void cresc(int vetor[]){

    int aux;

    for(int a=0;a

  • return EXIT_SUCCESS;

    }

  • ShellSort

    Vantagens:

    Shellsort uma tima opo para arquivos de tamanho moderado;

    Sua implementao simples e requer uma quantidade de cdigo pequena.

    Desvantagens:

    O tempo de execuo do algoritmo sensvel ordem inicial do arquivo;

    O mtodo no estvel.

    void shellSort(int *vet, int size) { //Vou assumir que o tamanho do vetor 8 ( size = vet[7]) int i , j , value; int gap = 1; while(gap < size) { gap = 3*gap+1; //Aqui definido o espaamento entre a verificao } //das variveis atravs do gap while ( gap > 1) { //Tendo nota que seu valor no pode ser maior que gap /= 3; //o tamanho do vetor que ser ordenado for(i = gap; i < size; i++) { value = vet[i]; //Vai pegando o valor no vetor com o espaamento (Se gap for 4, pegar o ndex 4, na prox rodada do for, pega o ndex 5 etc.) j = i - gap; //Mesma coisa que em cima, s que vai passando os ndex 0,1,2,3 para o J (A varivel value pega os valores do ndex 4,5,6,7) while (j >= 0 && value < vet[j]) { // Faz a verificao, basicamente se a varivel do ndex 4 for menor que a do ndex 0, vet [j + gap] = vet[j]; // eles trocam de posio (Alis, s um valor trocado por enquanto) j -= gap; // Aqui ele vai saindo do while depois de fazer as verificaes, deixando o J menor que 0 } vet [j + gap] = value; //Aqui o outro valor trocado, aquele que estava armazenado em value, note que o J s armazenou posio, } // enquanto o value armazenou o valor que estava na posio

    }

    }

  • QuickSort

    Vantagens

    extremamente eficiente para ordenar arquivos de dados.

    Necessita de apenas uma pequena pilha como memoria auxiliar.

    Funciona muito bem com listas grandes de itens.

    Para dados bem bagunados o quicksort mais vantajoso por ser mais econmico.

    Desvantagens

    Sua implementao delicada e difcil. Um pequeno engano pode levar a efeitos inesperados para algumas entradas de dados.

    O mtodo no estvel.

    #include

    void Quick(int vetor[10], int inicio, int fim);

    int main(){

    int vetor[10] = {7, 9, 4, 3, 6, 1, 18, 2, 10, 5};

    int i;

    printf("Vetor desordenado:\n");

    for(i = 0; i < 10; i++){

    printf("%d ", vetor[i]);

    }

    printf("\n");

    Quick(vetor, 0, 9);

    printf("Vetor ordenado:\n");

    for(i = 0; i < 10; i++){

    printf("%d ", vetor[i]);

    }

    printf("\n");

    }

    void Quick(int vetor[10], int inicio, int fim){

    int pivo, aux, i, j, meio;

    i = inicio;

  • j = fim;

    meio = (int) ((i + j) / 2);

    pivo = vetor[meio];

    do{

    while (vetor[i] < pivo) i = i + 1;

    while (vetor[j] > pivo) j = j - 1;

    if(i i);

    if(inicio < j) Quick(vetor, inicio, j);

    if(i < fim) Quick(vetor, i, fim);

    }