exercicio de casa

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

int MenuMetodos()
{
   int x;

   printf("|--------------------------------------------|\n");
   printf("|             METODOS DE ORDENACAO           |\n");
   printf("|--------------------------------------------|\n");
   printf("|   1 -> Metodos de Ordenacao por Selecao    |\n");
   printf("|   2 -> Metodos de Ordenacao por Insercao   |\n");
   printf("|   3 -> Metodos de Ordenacao por Bolha      |\n");
   printf("|   4 -> Metodos de Ordenacao por Shellsort  |\n");
   printf("|   5 -> Metodos de Ordenacao por Quicksort  |\n");
   printf("|--------------------------------------------|\n");

   printf("Selecione um metodo de Ordenacao:  ");
   scanf("%d",&x);
   return x;
}

int Menutamanho (void)
{
   int y, aceitar=0;
   do {
   printf("\n");
   printf("|----------------------------|\n");
   printf("|      TAMANHO DOS VETORES   |\n");
   printf("|----------------------------|\n");
   printf("|       -> 100               |\n");
   printf("|       -> 1000              |\n");
   printf("|       -> 10000             |\n");
   printf("|       -> 100000            |\n");
   printf("|----------------------------|\n");

   printf("Digite o tamanho do vetor:  ");
   scanf("%d",&y);
   if(y != 100 && y != 1000 && y != 10000 && y != 100000)
{
   printf("Digite o valor da Opcao correta!\n");
   aceitar=0;
   continue;
}
else
   aceitar=1;
}
while(aceitar == 0);
return y;
}

int MenuOrdem()
{
int z;

    printf("\n");
    printf("|-----------------------------|\n");
    printf("|      ORDEM DOS VETORES      |\n");
    printf("|-----------------------------|\n");
    printf("|      1 -> Crescente         |\n");
    printf("|      2 -> Decrescente       |\n");
    printf("|      3 -> Aleatorio         |\n");
    printf("|-----------------------------|\n");

    printf("Selecione a ordem de geracao dos vetores:  ");
    scanf("%d",&z);
return z;
}


// Crescente
void geraCrescente(int vet[], int tamanho)

{
    int p;
    for(p=0;p<tamanho;p++)
  {
    vet[p] = p;
    printf("\t%5d", p);
}
}

// Decrescente
void geraDecrescente(int vet[], int tamanho)
{
     int p, i=0;
     for(p=tamanho-1;p>=0;p--)
     {
         vet[i] = p;
         i++;
         printf("\t%5d", p);
     }

}


// Aleatorio
void geraAleatorio(int vet[], int tamanho)
{


     int i; //nao ha necessidade do "p".
     srand(time(NULL));
     for(i=0; i<tamanho; i++)
   {
     vet[i] = (rand() %tamanho)+1;//sempre q for sortear,faça somando com 1
     printf("\t%5d", vet[i]); //aqui vc quer tds os numeros do vetor no indice i,e nao apenas um numero(p),como vc tinha feito!
   }
}

//Gerar o vetor
int geraVetor (int vet[], int tamanho, int z)
{


    switch (z) // switch do geravetor.
    {
            case 1: geraCrescente (vet, tamanho); break;
            case 2: geraDecrescente (vet, tamanho); break;
            case 3: geraAleatorio (vet, tamanho); break;

            default: break;
}
}
// Ordenar conforme a escolha do usuário
// Seleção
void ordenaSelecao (int vet[], int tamanho)
{
   int i, j, aux, menor;


   // Ordenacao pelo metodo da seleção direta
   for(i=0;i<tamanho-1;i++)
   {
      menor = i;
      for(j=i+1;j<tamanho;j++)
         {
              if(vet[j] < vet[menor])
              menor = j;
         }
      aux = vet[i];
      vet[i] = vet[menor];
      vet[menor] = aux;

   }

   // Mostra vetor ordenado
   printf("\nVetor ordenado:\n");
   for(i=0;i<tamanho;i++)
       printf("\t %5d",i+1,vet[i]);
}


// Inserção
void ordenaInsercao (int vet[], int tamanho)
{
   int i, j, aux;

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

      j = i;
      while(vet[j] < vet[j - 1])
      {

              aux = vet[j];
              vet[j] = vet[j - 1];
              vet[j - 1] = aux;
              j--;
      if(j == 0)break;
      }
  }

   for(i=0; i<tamanho; i++)
       printf("\t %5d", vet[i]);
}


// Bolha
void ordenaBolha (int vet[], int qtd)
{
   int i, aux, tamanho=qtd;
   int trocou;
   do
   {
       qtd--;
       trocou=0;
       for (i=0;i<qtd;i++)
      {
       if (vet[i]>vet[i+1])
              {
                aux = vet[i];
                vet[i] = vet[i+1];
                vet[i+1] = aux;
                trocou=1;
              }
      }

   } while (qtd!=0);

      for(i=0; i<tamanho; i++)
      printf("\t %5d", vet[i]);
}


// Quicksort
void printV (int v[], int n)
{
     int i;
     for(i =0;i<n;i++)
     printf("\t %5d", v[i]);
}

int separa (int v[], int p, int r)
{
     int c = v[p], i = p+1, j = r, t;
     while (1)
   {
       while (i<= r && v[i] <= c) ++i;

       while (c < v[j] && j>=0) --j;

       if (i >= j)

       break;

       t = v[i], v[i] = v[j], v[j] = t;
       ++i;
       --j;
   }

                v[p] = v[j], v[j] = c;



return j;

}
void quicksort (int v[], int p, int r)
{
     int j;
     if (p < r)
   {
       j = separa (v, p, r);
       quicksort (v, p, j-1);
       quicksort (v, j+1, r);
   }
}


// Shellsort
void shellSort(int  vet[], int size)
{
    int i , j , value;
    int gap = 1;
    do
    {
        gap = 3*gap+1;
    }
    while(gap < size);
    do
    {
      gap /= 3;
      for(i = gap; i < size; i++)
        {
            value =vet[i];
            j = i - gap;
            while (j >= 0 && value < vet[j])
            {
                vet [j + gap] =vet[j];
                j -= gap;
            }
            vet [j + gap] = value;
        }
    }
    while ( gap > 1);

       for(i=0; i<size; i++)
       printf("\t %5d", vet[i]);
}


int main ()
{
    int metodos, tamanho, n, r,  vetores,s, ordem;
    int tempo;

    tamanho = Menutamanho ();
    ordem = MenuOrdem();
    int vet[tamanho];
    geraVetor(vet, tamanho, ordem);

      switch (ordem)
{
       case 1: // crescente

               metodos = MenuMetodos();
               switch (metodos)
{

                   case 1: // Seleção

                           tempo = clock();
                           ordenaSelecao (vet, tamanho);
                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;

                   case 2: // Inserçao
                           tempo = clock();
                           ordenaInsercao (vet, tamanho);
                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;
                   case 3: // Bolha
                           tempo = clock();
                           ordenaBolha (vet, tamanho);
                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;

                   case 4: // Shell
                           tempo = clock();
                           shellSort (vet, tamanho);
                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;

                   case 5: // Quick
                           tempo = clock();
                           printV (vet, tamanho);

                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;
                   default:
                            break;

}

               break;
      case 2: // decrescente
      metodos = MenuMetodos();
               switch (metodos)
{

                   case 1: // Seleção

                           tempo = clock();
                           ordenaSelecao (vet, tamanho);
                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;

                   case 2: // Inserçao
                           tempo = clock();
                           ordenaInsercao (vet, tamanho);
                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;
                   case 3: // Bolha
                           tempo = clock();
                           ordenaBolha (vet, tamanho);
                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;

                   case 4: // Shell
                           tempo = clock();
                           shellSort (vet, tamanho);
                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;

                   case 5: // Quick
                           tempo = clock();
                           printV (vet, tamanho);
                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;

                   default:
                            break;

}

               break;
     case 3: // Aleatorio
     metodos = MenuMetodos();
               switch (metodos)
{

                   case 1: // Seleção

                           tempo = clock();
                           ordenaSelecao (vet, tamanho);
                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;

                   case 2: // Inserçao
                           tempo = clock();
                           ordenaInsercao (vet, tamanho);
                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;
                   case 3: // Bolha
                           tempo = clock();
                           ordenaBolha (vet, tamanho);
                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;

                   case 4: // Shell
                           tempo = clock();
                           shellSort (vet, tamanho);
                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;

                   case 5: // Quick
                           tempo = clock();
                           printV (vet, tamanho);
                           tempo = clock() - tempo;

                           printf ("\n Tempo em milisegundo: %d \n", tempo);
                           system("pause");
                           break;

                   default:
                            break;

}
               break;
               }

system("pause");
return 0;
}