Ir ao conteúdo
  • Cadastre-se

C Metodo De Ordenação C.


Natal junio
Ir à solução Resolvido por arfneto,

Posts recomendados

alguém tem uma ideia de como posso fazer o código sem o meu menu pra executar todos de uma vez?, eu tentei remover o menu, pra rodar, mais da erro quando executar e compila. o código mostra o tempo de cada Método de ordenação. a quantida eu tava pensado em reduzir também, para M 100, K 1000, 10000

#include <stdlib.h>
#include <stdio.h>
#include <locale.h>
#include <time.h>
#include <windows.h>

#define m 1000
#define k 10000
#define o 100000
#define p 400000
#define true 1

void menu()
{
	printf("\n\nEscolha a quantidade de numeros que deseja saber o tempo!  \n");
	printf("\n 1 - 1000 números");
	printf("\n 2 - 10.000 números");
	printf("\n 3 - 100.000 números");
	printf("\n 4 - 400.000 números");
	printf("\n 5 - SAIR\n\n");
	
}

void menu2()
{
	printf("\n\nEscolha o metodo de ordenacao!  \n");
	printf("\n 1 - Insertion Sort");
	printf("\n 2 - Selection Sort");
	printf("\n 3 - Buble Sort");
	printf("\n 4 - Merge Sort");
	printf("\n 5 - Quick Sort");
	printf("\n 6 - Heap Sort");
	printf("\n 7 - SAIR\n\n");
	
}

void Insertion_Sort(int vet[ ],int n)
{
	int i,j,aux;
	for (i=1; i<n; i++)
	{
		aux = vet[i];
		
		for(j=i-1; j>=0 && vet[j] > aux; j--)
		{
			vet[j+1]=vet[j];
		}
		vet[j+1]=aux;
	}
}

void Merge_Sort(int vetor[], int tamanho){
	
  int meio = tamanho / 2;
  int i = 0;
  int j = meio;
  int t = 0;
  int aux[tamanho];
  
	while( i < meio && j < tamanho ){
	    if( vetor[i] <= vetor[j] )
	    	aux[t] = vetor[i++];
	    else
	    	aux[t] = vetor[j++];
	    t++;
	}
 
	if( i == meio ){
    	while( j < tamanho ){
            aux[t] = vetor[j++];
            t++;
      }
	}else {
    	while( i < meio ){
            aux[t] = vetor[i++];
            t++;
    	}
	}
	
	for( i = 0; i < tamanho; i++ ){
    	vetor[i] = aux[i];
	}
}

int Merge_SortRec(int vetor[], int tamanho)
{
	int meio = tamanho / 2;

	if( tamanho > 1 ){
		Merge_SortRec(vetor, meio);
		Merge_SortRec(vetor + meio, tamanho - meio);
		Merge_Sort(vetor, tamanho);
	}
}

void selectionSort(int vet[], int tam){
	
	int i, j, eleito, menor, pos;
	
	for(i=0; i<=tam; i++){
		eleito = vet[i];
		menor = vet[i+1];
		pos = i+1;
		
		for(j=i+1; j<=tam; j++){
			if(vet[j] < menor){
				menor = vet[j];
				pos = j;
			}
		}
		
		if(menor < eleito){
			vet[i] = vet[pos];
			vet[pos] = eleito;
		}
	}
}

void bubbleSort(int vet[], int tam){
	
	int i, n, aux;
	int troca;
	
	troca = 1;
	
	while (n < tam && troca == 1){
		troca = 0;
		
		for(i=0; i<tam; i++){
			if(vet[i] > vet[i+1]){
				troca = 1;
				aux = vet[i];
				vet[i] = vet[i+1];
				vet[i+1] = aux;
			}	
		}
		
		n = n+1;
	}
}

void quickSort(int vet[], int esq, int dir) {
    
	int i, j, pivo, aux;
	int qtd;
     
    i = esq;
    
    j = dir;
    
    pivo = vet[(esq + dir) / 2];
    
    while(i <= j) {
    	
        while(vet[i] < pivo && i < dir) {
            i++;
        }
        
        while(vet[j] > pivo && j > esq) {
            j--;
        }
        
        if(i <= j) {
            aux = vet[i];
            vet[i] = vet[j];
            vet[j] = aux;
            i++;
            j--;
        }
    }
    
    if(j > esq) {
        quickSort(vet, esq, j);
    }
    if(i < dir) {
        quickSort(vet, i, dir);
    }
}

void heapSort(int a[], int n) {
	
	int i = n / 2, pai, filho, t;
   
	while(true) {
   	
		if (i > 0) {
        	
			i--;
        	
        	t = a[i];
    	} else {
        	
			n--;
        	
          	if (n <= 0) return;
          	
          	t = a[n];
			 
          	a[n] = a[0];
      	}
      	
		pai = i;
		
      	filho = i * 2 + 1;
      	
		while (filho < n) {
        	if ((filho + 1 < n)  &&  (a[filho + 1] > a[filho]))
              	filho++;

          	if (a[filho] > t) {
             	a[pai] = a[filho];
             	pai = filho;
             	filho = pai * 2 + 1;
          	} else {
          		// Sai do laco de repeticao
            	break;
        	}
      }
      
	  a[pai] = t;
   }
}

int main()
{
	setlocale (LC_ALL, "");
	int vet[p],i,j,op,op2;
 	LARGE_INTEGER tempoInicial, tempoFinal, freq;
 	float tempoTotal;
 	
 	do{
 		menu2();
 		scanf("\n\n%d",&op2);
 		switch(op2){
 			case 1:
 				do{
					menu();
					scanf("\n\n%d",&op);			
					switch(op)
					{
						case 1:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<m; i++)
								{
				    				vet[i] = rand() % m;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								Insertion_Sort(vet,m);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 2:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<k; i++)
								{
				    				vet[i] = rand() % k;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								Insertion_Sort(vet,k);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
							break;
							
						case 3:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<o; i++)
								{
				    				vet[i] = rand() % o;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								Insertion_Sort(vet,o);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
							break;
						
						case 4:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<p; i++)
								{
				    				vet[i] = rand() % p;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								Insertion_Sort(vet,p);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
							break;
						case 5:
							system ("cls");
							printf("\n\nFinalizado\n\n");
							return 0;
							break;
					}
				}while(op != 5);
			case 2:
				do{
					menu();
					scanf("\n\n%d",&op);			
					switch(op)
					{
						case 1:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<m; i++)
								{
				    				vet[i] = rand() % m;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								selectionSort(vet, m);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 2:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<k; i++)
								{
				    				vet[i] = rand() % k;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								selectionSort(vet, k);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 3:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<o; i++)
								{
				    				vet[i] = rand() % o;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								selectionSort(vet, o);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 4:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<p; i++)
								{
				    				vet[i] = rand() % p;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								selectionSort(vet, p);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 5:
							system ("cls");
							printf("\n\nFinalizado\n\n");
							return 0;
							break;
					}
				}while(op != 5);
			case 3:
	do{
					menu();
					scanf("\n\n%d",&op);			
					switch(op)
					{
						case 1:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<m; i++)
								{
				    				vet[i] = rand() % m;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								bubbleSort(vet, m);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 2:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<k; i++)
								{
				    				vet[i] = rand() % k;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								bubbleSort(vet, k);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 3:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<o; i++)
								{
				    				vet[i] = rand() % o;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								bubbleSort(vet, o);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 4:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<p; i++)
								{
				    				vet[i] = rand() % p;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								bubbleSort(vet, p);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 5:
							system ("cls");
							printf("\n\nFinalizado\n\n");
							return 0;
							break;
					}
				}while(op != 5);
			case 4:
				do{
					menu();
					scanf("\n\n%d",&op);			
					switch(op)
					{
						case 1:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<m; i++)
								{
				    				vet[i] = rand() % m;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								Merge_SortRec(vet, m);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 2:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<k; i++)
								{
				    				vet[i] = rand() % k;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								Merge_SortRec(vet, k);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 3:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<o; i++)
								{
				    				vet[i] = rand() % o;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								Merge_SortRec(vet, o);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 4:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<p; i++)
								{
				    				vet[i] = rand() % p;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								Merge_SortRec(vet, p);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 5:
							system ("cls");
							printf("\n\nFinalizado\n\n");
							return 0;
							break;
					}
				}while(op != 5);
			case 5:
				do{
					menu();
					scanf("\n\n%d",&op);			
					switch(op)
					{
						case 1:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<m; i++)
								{
				    				vet[i] = rand() % m;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								quickSort(vet, 0, m-1);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 2:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<k; i++)
								{
				    				vet[i] = rand() % k;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								quickSort(vet, 0, k-1);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 3:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<o; i++)
								{
				    				vet[i] = rand() % o;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								quickSort(vet, 0, o-1);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 4:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<p; i++)
								{
				    				vet[i] = rand() % p;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								quickSort(vet, 0, p-1);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 5:
							system ("cls");
							printf("\n\nFinalizado\n\n");
							return 0;
							break;
					}
				}while(op != 5);
			case 6:
				do{
					menu();
					scanf("\n\n%d",&op);			
					switch(op)
					{
						case 1:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<m; i++)
								{
				    				vet[i] = rand() % m;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								heapSort(vet, m);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 2:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<k; i++)
								{
				    				vet[i] = rand() % k;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								heapSort(vet, k);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 3:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<o; i++)
								{
				    				vet[i] = rand() % o;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								heapSort(vet, o);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 4:
							system ("cls");
							srand(time(NULL));
							for (i=0; i<p; i++)
								{
				    				vet[i] = rand() % p;
								}
								printf("Aguarde...");
								QueryPerformanceCounter(&tempoInicial);
								heapSort(vet, p);
					 			QueryPerformanceCounter(&tempoFinal);
					 			QueryPerformanceFrequency(&freq);
					 			tempoTotal = (float)(tempoFinal.QuadPart - tempoInicial.QuadPart)/freq.QuadPart;
					 
				    			printf("\n\n");
				    			printf(" Tempo de Exeução em Milissegundos: %f\n", tempoTotal);
						break;
						case 5:
							system ("cls");
							printf("\n\nFinalizado\n\n");
							return 0;
							break;
					}
				}while(op != 5);
			case 7:
				system ("cls");
				printf("\n\nFinalizado\n\n");
				break;
		 }
	}while(op2 != 7);
	printf("\n\n");
	system("pause");
	return 0;

}

 

Link para o comentário
Compartilhar em outros sites

Postei esse exemplo aqui semanas atrás e faz o que você quer.

 

No caso apenas crie uma função que recebe o endereço do vetor e o endereço da função de classificação, nos moldes da função seletor() que está  no programa abaixo. Era um exemplo simles de VFT em C, uma tabela de funções, que é o que você quer.

#include "stdio.h"
#include <Windows.h>

typedef int (*pF_int_int)(int, int);


int		funcao_1(int, int);
int		funcao_2(int, int);
int		funcao_3(int, int);

int		seletor(int, pF_int_int*);

int main(int argc, char** argv)
{
	pF_int_int VFT[4]; // nao usei f[0] so porque nao
	int (*pF)(int, int) = NULL;
	printf("\nChama as 3 funcoes pela ordem\n");
	funcao_1(1, 2);
	funcao_2(3, 4);
	funcao_3(5, 6);

	VFT[1] = funcao_1;
	VFT[2] = funcao_2;
	VFT[3] = funcao_3;

	printf("\nChama as 3 funcoes a partir do vetor de enderecos\n");
	VFT[1](11, 22);
	VFT[2](33, 44);
	VFT[3](55, 66);

	printf("\nChama as 3 funcoes a partir de uma funcao seletora\n");
	for (int i = 1; i <= 3; i += 1)	seletor(i, VFT);
	return 0;
}

int		funcao_1(int a, int b)
{	printf("Ola!Esta e a funcao_1(%d,%d)\n", a, b);
	return 0;
};

int		funcao_2(int a, int b)
{	printf("Ola!Esta e a funcao_2(%d,%d)\n", a, b);
	return 0;
};

int		funcao_3(int a, int b)
{	printf("Ola!Esta e a funcao_3(%d,%d)\n", a, b);
	return 0;
};

int		seletor(int qual, pF_int_int* VFT)
{
	if ((qual < 1) || (qual > 3)) return -1;

	printf("\nseletor(%d) Chama funcao_%d()\n", qual, qual);
	(*VFT[qual])(qual * 100, qual * 100);	// chama a funcao pelo numero
	return 0;
};

Eis a saida do programa 


Chama as 3 funcoes pela ordem
Ola!Esta e a funcao_1(1,2)
Ola!Esta e a funcao_2(3,4)
Ola!Esta e a funcao_3(5,6)

Chama as 3 funcoes a partir do vetor de enderecos
Ola!Esta e a funcao_1(11,22)
Ola!Esta e a funcao_2(33,44)
Ola!Esta e a funcao_3(55,66)

Chama as 3 funcoes a partir de uma funcao seletora

seletor(1) Chama funcao_1()
Ola!Esta e a funcao_1(100,100)

seletor(2) Chama funcao_2()
Ola!Esta e a funcao_2(200,200)

seletor(3) Chama funcao_3()
Ola!Esta e a funcao_3(300,300)

Se não entender volte a escrever

 

Essa é a linha importante do programa 

	printf("\nChama as 3 funcoes a partir de uma funcao seletora\n");
	for (int i = 1; i <= 3; i += 1)	seletor(i, VFT);

 

 

 

Link para o comentário
Compartilhar em outros sites

Me lembrei de que eu postei um programa que faz exatamente isso, nesse tópico 

O que importa é essa função

double testa_funcao(uint64_t(*funcao)(uint64_t), uint64_t limite)
{
	uint64_t v;
	clock_t  tempo = clock();
	for (uint64_t target = 1; target <= limite; target += 1)
		v = (*funcao)(target);
	tempo = clock() - tempo;
	return (double)(tempo) / CLOCKS_PER_SEC;
};	// testa_funcao()

no caso usada assim 


	printf("Usando a funcao original...\n");
	secsB = testa_funcao(non_fib_original, limite);
	printf("Tempo usando a funcao original = %6.3fs\n", secsB);
	printf("Usando a funcao \"nova\"...\n");
	secsA = testa_funcao(non_fib_nova, limite);
	printf("Tempo  usando a  funcao  nova  = %6.3fs\n", secsA);
		printf("\nTempo nova/original = %6.3g. Performance da nova = %6.2fX da original\n",
		secsA/secsB, (secsB/secsA));

basta adaptar para seu caso e seria assim a declaração

double		testa_funcao_v(void(*f)(int[], int), int[], int);

E o uso por exemplo

    secsA = testa_funcao_v(bubbleSort, vet, tam);
	
    secsA = testa_funcao_v(MergeSort, vet, tam);
	
    secsA = testa_funcao_v(InsertionSort, vet, tam);

Ou pode juntar todas em um vetor e usar como no primeiro exemplo, uma tabela de ponteiros para funções de sort... e aí fazer suas contas.

 

 

Link para o comentário
Compartilhar em outros sites

@arfneto entendo, No caso eu teria que criar a Função, ou apenas substituir?

quando executo o se código no programa da o seguinte erro, nessa linha.

for (int i = 1; i <= 3; i += 1)	seletor(i, VFT);

  [Error] 'for' loop initial declarations are only allowed in C99 or C11 mode

  [Note] use option -std=c99, -std=gnu99, -std=c11 or -std=gnu11 to compile your code

Link para o comentário
Compartilhar em outros sites

  • Solução
2 horas atrás, Natal junio disse:

[Error] 'for' loop initial declarations are only allowed in C99 or C11 mode

  [Note] use option -std=c99, -std=gnu99, -std=c11 or -std=gnu11 to compile your code

 

Está usando uma definição muito antiga da linguagem. Isso é o que a mensagem está dizendo.

 

Sugiro sempre usar um compilador moderno e ajustado para uma versão moderna da linguagem, como essa opção aí -std=gnu11, ou std=gnu14, ou std=gnu17 para usar as versões de C++ relativas ao padrão desses anos, 2011, 2014, 2017...

 

A linguagem vem sempre evoluindo e não há razão para usar versões antigas. Ainda mais com compiladores grátis e de qualidade disponíveis para vários ambientes. 

 

  • Curtir 1
Link para o comentário
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisa ser um usuário 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 comunidades 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

×
×
  • Criar novo...