Método de ordenação Heap Sorte, feito em projeto.

Necessário ter os 3 arquivos para funcionar. Copie cada um em seu respectivo arquivo. Verifique se os nomes dos arquivos e seus respectivos #include no código-fonte.

• Download HEAP SORT.rar
• Enviar nova versão

Esconder código-fonte

//////MAIN//////
/*
DESENVOLVIDO POR LEONE DUARTE DE OLIVEIRA
MATERIA: ORDENAÇÃO E PESQUISA
PROFESSOR:MAICON RIBEIRO
DATA: 29/03/2018
*/
#include"heap.h"

main(){
   int tamanho_vetor, *vetor,contador,contador2=0,maior,cont,sair=0,menu1;
   int aux;
   
   while(sair==0){
      printf("\n\t\t--------------------------------------\n");
      printf("\n\t\t\tORDENACAO USANDO HEAP SORT\n\n\t\t\t1-GERAR NOVO VETOR\n\t\t\t2-SAIR\n\t\t\t>>>>>");
      printf("\n\t\t--------------------------------------\n");
      scanf("%d",&menu1);
      system("cls");
      
      switch(menu1){
         
         case 1:
            printf("\nINSIRA O TAMANHO DO VETOR:\n");
            scanf("%d",&tamanho_vetor);
            
            vetor = malloc(sizeof(int)* (tamanho_vetor)); 
            srand(time(NULL));
         
            //gerando vetores aleatorios
            for(contador = 0; contador < tamanho_vetor; contador++){
               vetor[contador]= rand()%100;   
            }
            
            //exibindo desordenado
            for(contador2=0; contador2 < tamanho_vetor; contador2++){
               printf("numero %d: %d\n",contador2,vetor[contador2]);
            }
            
            printf("\n\n--------------------------------------\n\n");
            
            clock_t hora_inicial = clock();
            heap_sort(vetor, tamanho_vetor);
                        
            cont = tamanho_vetor-1;
                              
            while(cont >= 0 ){
               //mandando o maior para o começo
               heap_sort(vetor, cont);
               //mandando maior para o final
               for(contador = 0; contador < cont; contador++){
                  
                  aux = vetor[contador];
                  vetor[contador] = vetor[contador+1];
                  vetor[contador+1] = aux;
                                 
               }
               
               heap_sort(vetor, cont);   
               cont--;
            }
            clock_t hora_final = clock();
            
            //exibindo organizado            
            for(contador2 = 0; contador2 < tamanho_vetor; contador2++){
               printf("numero %d: %d\n",contador2, vetor[contador2]);
               
            }
            double tempo_gasto = ( (double) (hora_final - hora_inicial) ) / CLOCKS_PER_SEC;
               printf("TEMPO GASTO USANDO HEAP SORT: %lf s\n", tempo_gasto);
            
            system("pause");
            system("cls");
         break;
         
         case 2:
            printf("\nATE LOGO...");
            sair=1;
            
         break;
            
      }
   }
}
//////////////////////////////////////////////////////////////////////////////////////////////////////HEAP.C/////////////////////////////////////////////////////////////////////////////////////////////////
#include"heap.h"

int heap_sort(int *vetor, int tamanho){
   
   int pai_direita, pai_esquerda, aux, contador;

   
   for(contador = tamanho-1;  contador >= 0;  contador-- ){
      
      //descobrindo o a raiz de cada galho
      pai_direita  = (contador / 2) - 1;
      pai_esquerda = (contador - 2) / 2;
      
      //trocando caso a raiz seja manor que o galho da direita
       if(vetor[contador] > vetor[pai_direita]){
         
         aux = vetor[contador];
         vetor[contador] = vetor[pai_direita];
         vetor[pai_direita] = aux;         
         
      }
      
      //trocando caso a raiz seja menor que o galhp da esquerda
      else if (vetor[contador-1] > vetor[pai_esquerda] ){

         aux = vetor[contador-1];
         vetor[contador-1] = vetor[pai_esquerda];
         vetor[pai_esquerda] = aux;
         
      }

   }
}

///////HEAP.H/////
#include<stdlib.h>
#include<stdio.h>
#include<time.h>

int heap_sort(int *vetor, int tamanho);//recebe um vetor um tamanho com o objetivo de mover o maior valor sempre para primeira posição

Lista simplesmente encadeada com busca auto-organizada

Desenhando Nuvens ou o Fractal de Plasma

Pilha Encadeada

Ordenação Bolha

Pilha

Nenhum comentário foi encontrado.