C Metodo De Ordenação C.

Natal junio · 28 de fevereiro de 2020

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, O 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;

}

arfneto · 28 de fevereiro de 2020

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

arfneto · 28 de fevereiro de 2020

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.

Natal junio · 2 de março de 2020

@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

arfneto · 2 de março de 2020

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.