giiff / livro_algoritmos_e_estruturas_de_dados

Livro Algoritmos e Estruturas de Dados para Tecnólogos

Creative Commons Attribution Share Alike 4.0 International

13 stars 0 forks source link

Exe02 - Merge Sort adaptado para reportar tempos e trocas #5

Closed waldeyr closed 5 years ago

waldeyr commented 5 years ago

Deixe aqui seu código com seu nome no comentátio;

4ven commented 5 years ago

// Samuel Sergio Garcia Espinosa

#include<stdlib.h> 
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define TAMANHO 100000
void merge(int vetor[], int inicio, int meio, int fim);
void mergeSort(int vetor[], int inicio, int meio);

void mostrarDados(long comp, long trocas, long tempo)
{
    printf("Quantidade de comparaçoes: %ld \n", comp);
    printf("Quantidade de trocas: %ld \n", trocas);
    printf("Tempo gasto: %ld", tempo);
    printf("\n");
}

long qComp, qTrocas;

void main()
{
    long tempoR, tempoC, tempoD;
    int vetorR[TAMANHO], vetorC[TAMANHO], vetorD[TAMANHO]; //vetor com tamanho definido
    clock_t tempoInicial, tempoFinal; //Variaveis para guardar o tempo de execucao
    srand(time(NULL)); //Cria uma semente para numeros aleatorios

    // VALORES RANDOMICOS
    tempoInicial = clock(); //inicia contagem do tempo
    for (int i = 0; i < TAMANHO; i++)
        vetorR[i] = rand() % 10; //Atribui um inteiro aleatorio entre 0 e 9

    //Chama a fucao passando o vetor como parametro
    mergeSort(vetorR, 0, TAMANHO - 1);
    printf("\n");

    tempoFinal = clock(); //finaliza contagem do tempo
    tempoR = tempoFinal - tempoInicial;

    //calcula e mostra o tempo total de execucao
    printf("Valores Randomicos \n");
    mostrarDados(qComp, qTrocas, tempoR);

    // VALORES CRESCENTES
    qComp = 0;
    qTrocas = 0;
    tempoInicial = clock(); //inicia contagem do tempo
    for (int i = 0; i < TAMANHO; i++)
        vetorC[i] = i+1; 

    //Chama a fucao passando o vetor como parametro
    mergeSort(vetorC, 0, TAMANHO - 1);
    printf("\n");

    tempoFinal = clock(); //finaliza contagem do tempo
    tempoC = tempoFinal - tempoInicial;

    printf("Valores Crescentes \n");
    mostrarDados(qComp, qTrocas, tempoC);

    // VALORES DECRESCENTES
    qComp = 0;
    qTrocas = 0;
    long count = TAMANHO;
    tempoInicial = clock(); //inicia contagem do tempo
    for (int i = 0; i < TAMANHO; i++)
    {
        vetorD[i] = count; 
        count--;
    }

    //Chama a fucao passando o vetor como parametro
    mergeSort(vetorD, 0, TAMANHO - 1);
    printf("\n");

    tempoFinal = clock(); //finaliza contagem do tempo
    tempoD = tempoFinal - tempoInicial;

    printf("Valores Decrescentes \n");
    mostrarDados(qComp, qTrocas, tempoD);
}

void merge(int vetor[], int inicio, int meio, int fim) {
    int i, j, k;
    int n1 = meio - inicio + 1;
    int n2 = fim - meio;
    int L[n1], R[n2];
    for (i = 0; i < n1; i++)
        L[i] = vetor[inicio + i];
    for (j = 0; j < n2; j++)
        R[j] = vetor[meio + 1 + j];
    i = 0;
    j = 0;
    k = inicio;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            vetor[k] = L[i];
            i++;
        }
        else {
            vetor[k] = R[j];
            j++;
            qTrocas++;
        }
        qComp++;
        k++;
    }
    while (i < n1) {
        vetor[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        vetor[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(int vetor[], int inicio, int fim) {
    if (inicio < fim) {
        int m = inicio + (fim - inicio) / 2;
        mergeSort(vetor, inicio, m);
        mergeSort(vetor, m + 1, fim);
        merge(vetor, inicio, m, fim);
    }
}

Judy-Ellen commented 5 years ago

Judy Ellen Vera Martins 20171070130234

include

define TAMANHO 10

void merge(int vetor[], int inicio, int meio, int fim); void mergeSort(int vetor[], int inicio, int meio); int troc, comp; void main() { int vetor[TAMANHO]; clock_t tempoInicial, tempoFinal; srand(time(NULL)); tempoInicial = clock(); for (int i = 0; i < TAMANHO; i++) { vetor[i] = rand() % 10; } //Mostra valores do vetor nao ordenado for (int i = 0; i < TAMANHO; i++) { printf("%d\t", vetor[i]); } printf("\n"); mergeSort(vetor, 0, TAMANHO - 1); //Mostra valores do vetor ordenado
for (int i = 0; i < TAMANHO; i++) { printf("%d\t", vetor[i]); } printf("\n"); //Ordem Decrescente for (int i = 0;i < TAMANHO;i++){ vetor[i] = TAMANHO - i - 1; printf("%d\t", vetor[i]); } tempoFinal = clock();
printf("\nTempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC); printf("\nTroca: %d", troc); printf("\nComparação: %d", comp); } void merge(int vetor[], int inicio, int meio, int fim) { int i, j, k; int n1 = meio - inicio + 1; int n2 = fim - meio; int L[n1], R[n2]; for (i = 0; i < n1; i++) L[i] = vetor[inicio + i]; for (j = 0; j < n2; j++) R[j] = vetor[meio + 1 + j]; i = 0; j = 0; k = inicio; while (i < n1 && j < n2) { //Faz a comparação comp++; if (L[i] <= R[j]) { //Faz a contagem das trocas troc++; vetor[k] = L[i]; i++; } else { vetor[k] = R[j]; j++; } k++; } while (i < n1) { vetor[k] = L[i]; i++; k++; } while (j < n2) { vetor[k] = R[j]; j++; k++; }
} void mergeSort(int vetor[], int inicio, int fim) { if (inicio < fim) { int m = inicio + (fim - inicio) / 2; mergeSort(vetor, inicio, m); mergeSort(vetor, m + 1, fim); merge(vetor, inicio, m, fim); } }

LarissaJacobina commented 5 years ago

Larissa S. Jacobina

#include<stdlib.h> 
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define TAMANHO 100000 
void merge(int vetor[], int inicio, int meio, int fim);
void mergeSort(int vetor[], int inicio, int meio);
    int comp = 0, troca = 0;
int aleatorio(){

    int vetor[TAMANHO]; //vetor com tamanho definido
    clock_t tempoInicial, tempoFinal; //Variaveis para guardar o tempo de execucao
    srand(time(NULL)); //Cria uma semente para numeros aleatorios
    tempoInicial = clock(); //inicia contagem do tempo
    for (int i = 0; i < TAMANHO; i++) {
        vetor[i] = rand() % 10; //Atribui um inteiro aleatorio entre 0 e 9
    }
    //Mostra valores do vetor nao ordenado
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\n");
    //Chama a fucao passando o vetor como parametro
    mergeSort(vetor, 0, TAMANHO - 1);
    //Mostra valores do vetor ordenado   
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\nComparação: %d", comp);
    printf("\nTroca: %d", troca);
    printf("\n");
    tempoFinal = clock(); //finaliza contagem do tempo
    //calcula e mostra o tempo total de execucao
    printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC);
}

int crescente() {
    int vetor[TAMANHO]; //vetor com tamanho definido
    clock_t tempoInicial, tempoFinal; //Variaveis para guardar o tempo de execucao
    //srand(time(NULL)); //Cria uma semente para numeros aleatorios
    tempoInicial = clock(); //inicia contagem do tempo
    for (int i = 0; i < TAMANHO; i++) {
        vetor[i] = i; //Atribui um inteiro aleatorio entre 0 e 9
    }
    //Mostra valores do vetor nao ordenado
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\n");
    //Chama a fucao passando o vetor como parametro
    mergeSort(vetor, 0, TAMANHO - 1);
    //Mostra valores do vetor ordenado   
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\nComparação: %d", comp);
    printf("\nTroca: %d", troca);
    printf("\n");
    tempoFinal = clock(); //finaliza contagem do tempo
    //calcula e mostra o tempo total de execucao
    printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC);
}

int decrescente() {
    int vetor[TAMANHO]; //vetor com tamanho definido
    clock_t tempoInicial, tempoFinal; //Variaveis para guardar o tempo de execucao
    //srand(time(NULL)); //Cria uma semente para numeros aleatorios
    tempoInicial = clock(); //inicia contagem do tempo
    for (int i = 0; i < TAMANHO; i++) {
        vetor[i] = TAMANHO - i; //Atribui um inteiro aleatorio entre 0 e 9
    }
    //Mostra valores do vetor nao ordenado
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\n");
    //Chama a fucao passando o vetor como parametro
    mergeSort(vetor, 0, TAMANHO - 1);
    //Mostra valores do vetor ordenado   
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\nComparação: %d", comp);
    printf("\nTroca: %d", troca);
    printf("\n");
    tempoFinal = clock(); //finaliza contagem do tempo
    //calcula e mostra o tempo total de execucao
    printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC);
}

void merge(int vetor[], int inicio, int meio, int fim) {
    int i, j, k;
    int n1 = meio - inicio + 1;
    int n2 = fim - meio;
    int L[n1], R[n2];
    for (i = 0; i < n1; i++)
        L[i] = vetor[inicio + i];
    for (j = 0; j < n2; j++)
        R[j] = vetor[meio + 1 + j];
    i = 0;
    j = 0;
    k = inicio;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            vetor[k] = L[i];
            i++;

        } else {
            vetor[k] = R[j];
            j++;
            troca = troca + 1;
        }
        comp = comp + 1;
        k++;

    }
    while (i < n1) {
        vetor[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        vetor[k] = R[j];
        j++;
        k++;
    }

}

void mergeSort(int vetor[], int inicio, int fim) {
    if (inicio < fim) {
        int m = inicio + (fim - inicio) / 2;
        mergeSort(vetor, inicio, m);
        mergeSort(vetor, m + 1, fim);
        merge(vetor, inicio, m, fim);

    }
}

void main() {

    int opcao = 0;
    printf("Aleatório = 1\n Crescente = 2\n Decrescente = 3\n");
    printf("Ordem: ");
    scanf("%d", &opcao);
    printf("\n");

    switch (opcao) {
    case 1:
    aleatorio();
    break;

    case 2:
    crescente();
    break;

    case 3:
    decrescente();
    break;
    }
}

arthurjf commented 5 years ago

Aluno: Arthur José Fernandes

#include<stdlib.h> 
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define TAMANHO 100000

long qtd_comparacoes = 0, qtd_trocas = 0;

long comp_Ordenado, troc_Ordenado;
double temp_Ordenado;

long comp_Aleatorio, troc_Aleatorio;
double temp_Aleatorio;

long comp_Decrescente, troc_Decrescente;
double temp_Decrescente;

void merge(int vetor[], int inicio, int meio, int fim);
void mergeSort(int vetor[], int inicio, int meio);

void main() {
    int count = 0;
    for (int y = 1; y <= 3; y++) {
        qtd_comparacoes = 0;
        qtd_trocas = 0;
        int vetor[TAMANHO]; //vetor com tamanho definido
        clock_t tempoInicial = 0, tempoFinal = 0; //Variaveis para guardar o tempo de execucao
        srand(time(NULL)); //Cria uma semente para numeros aleatorios
        tempoInicial = clock(); //inicia contagem do tempo
        switch (y) {
                /* Aleatório */
            case 1:
                for (int i = 0; i < TAMANHO; i++) {
                    vetor[i] = rand() % 10; //Atribui um inteiro aleatorio entre 0 e 9
                }
                printf("\n\n----- Aleatória -----\n\n");
                break;

                /* Ordenado */
            case 2:
                for (int i = 0; i < TAMANHO; i++) {
                    vetor[i] = i;
                }
                printf("\n\n----- Ordenado -----\n\n");
                break;

                /* Decrescente */
            case 3:
                count = 0;
                for (int i = TAMANHO - 1; i >= 0; i--) {
                    vetor[count] = i;
                    count++;
                }
                printf("\n\n----- Decrescente -----\n\n");
                break;
        }
        //Mostra valores do vetor nao ordenado
        for (int i = 0; i < TAMANHO; i++) {
            printf("%d\t", vetor[i]);
        }
        printf("\n");
        //Chama a fucao passando o vetor como parametro
        mergeSort(vetor, 0, TAMANHO - 1);
        //Mostra valores do vetor ordenado   
        for (int i = 0; i < TAMANHO; i++) {
            printf("%d\t", vetor[i]);
        }
        printf("\n\n");
        printf("\n\n---------- -----------\n\n");
        tempoFinal = clock(); //finaliza contagem do tempo
        //calcula e mostra o tempo total de execucao

        switch (y) {
            case 1:
                temp_Aleatorio = (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC;
                troc_Aleatorio = qtd_trocas;
                comp_Aleatorio = qtd_comparacoes;
                break;
            case 2:
                temp_Ordenado = (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC;
                troc_Ordenado = qtd_trocas;
                comp_Ordenado = qtd_comparacoes;
                break;
            case 3:
                temp_Decrescente = (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC;
                troc_Decrescente = qtd_trocas;
                comp_Decrescente = qtd_comparacoes;
                break;
        }
    }
    for (int y = 1; y <= 3; y++) {
        switch (y) {
            case 1:
                printf("\n\n----- Aleatória -----\n\n");
                printf("Tempo: %f s\n", temp_Aleatorio);
                printf("Trocas = %ld\n", troc_Aleatorio);
                printf("Comparações = %ld\n", comp_Aleatorio);
                break;
            case 2:
                printf("\n\n----- Ordenado -----\n\n");
                printf("Tempo: %f s\n", temp_Ordenado);
                printf("Trocas = %ld\n", troc_Ordenado);
                printf("Comparações = %ld\n", comp_Ordenado);
                break;
            case 3:
                printf("\n\n----- Decrescente -----\n\n");
                printf("Tempo: %f s\n", temp_Decrescente);
                printf("Trocas = %ld\n", troc_Decrescente);
                printf("Comparações = %ld\n", comp_Decrescente);
                break;
        }
    }
    printf("\n\b---------- -----------\n\n");
}

void merge(int vetor[], int inicio, int meio, int fim) {
    int i, j, k;
    int n1 = meio - inicio + 1;
    int n2 = fim - meio;
    int L[n1], R[n2];
    for (i = 0; i < n1; i++) {
        L[i] = vetor[inicio + i];
    }
    for (j = 0; j < n2; j++) {
        R[j] = vetor[meio + 1 + j];
    }
    i = 0;
    j = 0;
    k = inicio;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            vetor[k] = L[i];
            i++;
        } else {
            vetor[k] = R[j];
            qtd_trocas++;
            j++;
        }
        qtd_comparacoes++;
        k++;
    }
    while (i < n1) {
        vetor[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        vetor[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(int vetor[], int inicio, int fim) {
    if (inicio < fim) {
        int m = inicio + (fim - inicio) / 2;
        mergeSort(vetor, inicio, m);
        mergeSort(vetor, m + 1, fim);
        merge(vetor, inicio, m, fim);
    }
}

gustavohgarcez commented 5 years ago

Aluno: Gustavo Henrique Garcez Andrade

#include<stdlib.h> 
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define TAMANHO 100000
void merge(int vetor[], int inicio, int meio, int fim);
void mergeSort(int vetor[], int inicio, int meio);
int comp = 0, troca = 0;

void aleatorio() {
    int vetor[TAMANHO]; //vetor com tamanho definido
    clock_t tempoInicial, tempoFinal; //Variaveis para guardar o tempo de execucao
    srand(time(NULL)); //Cria uma semente para numeros aleatorios
    tempoInicial = clock(); //inicia contagem do tempo
    for (int i = 0; i < TAMANHO; i++) {
        vetor[i] = rand() % 10; //Atribui um inteiro aleatorio entre 0 e 5
    }
    //Mostra valores do vetor nao ordenado
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\n");
    //Chama a fucao passando o vetor como parametro
    mergeSort(vetor, 0, TAMANHO - 1);
    //Mostra valores do vetor ordenado   
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }

    printf("\n");
    printf("Comparações: %d\nTrocas: %d\n", comp, troca);
    tempoFinal = clock(); //finaliza contagem do tempo
    //calcula e mostra o tempo total de execucao
    printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC);
}

void crescente() {
    int vetor[TAMANHO]; //vetor com tamanho definido
    clock_t tempoInicial, tempoFinal; //Variaveis para guardar o tempo de execucao
    tempoInicial = clock(); //inicia contagem do tempo
    for (int i = 0; i < TAMANHO; i++) {
        vetor[i] = i; //Atribui um inteiro aleatorio entre 0 e 5
    }
    //Mostra valores do vetor nao ordenado
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\n");
    //Chama a fucao passando o vetor como parametro
    mergeSort(vetor, 0, TAMANHO - 1);
    //Mostra valores do vetor ordenado   
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\n");
    printf("Comparações: %d\nTrocas: %d\n", comp, troca);
    tempoFinal = clock(); //finaliza contagem do tempo
    //calcula e mostra o tempo total de execucao
    printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC);
}

void decrescente() {
    int vetor[TAMANHO]; //vetor com tamanho definido
    clock_t tempoInicial, tempoFinal; //Variaveis para guardar o tempo de execucao
    tempoInicial = clock(); //inicia contagem do tempo
    for (int i = 0; i < TAMANHO; i++) {
        vetor[i] = TAMANHO - i; //Atribui um inteiro aleatorio entre 0 e 5
    }
    //Mostra valores do vetor nao ordenado
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\n");
    //Chama a fucao passando o vetor como parametro
    mergeSort(vetor, 0, TAMANHO - 1);
    //Mostra valores do vetor ordenado   
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\n");
    printf("Comparações: %d\nTrocas: %d\n", comp, troca);
    tempoFinal = clock(); //finaliza contagem do tempo
    //calcula e mostra o tempo total de execucao
    printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC);
}

void merge(int vetor[], int inicio, int meio, int fim) {
    int i, j, k;
    int n1 = meio - inicio + 1;
    int n2 = fim - meio;
    int L[n1], R[n2];
    for (i = 0; i < n1; i++)
        L[i] = vetor[inicio + i];
    for (j = 0; j < n2; j++)
        R[j] = vetor[meio + 1 + j];
    i = 0;
    j = 0;
    k = inicio;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            vetor[k] = L[i];
            i++;
        }
        else {
            vetor[k] = R[j];
            j++;
            troca = troca + 1;
        }
        comp = comp + 1;
        k++;
    }
    while (i < n1) {
        vetor[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        vetor[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(int vetor[], int inicio, int fim) {
    if (inicio < fim) {
        int m = inicio + (fim - inicio) / 2;
        mergeSort(vetor, inicio, m);
        mergeSort(vetor, m + 1, fim);
        merge(vetor, inicio, m, fim);
    }
}

void main() {

    int opcao = 0;
    printf("---------- Menu ----------");
    printf("\n| 1 - Aleatório  |\n| 2 - Crescente  |\n| 3 - Decrescente|");
    printf("\n| Escolha uma opção: ");
    scanf("%d", &opcao);

    switch (opcao) {
        case 1 :
        printf("\n----- Aleatório -----\n");
        aleatorio();
        break;

        case 2 :
        printf("\n----- Crescente -----\n");
        crescente();
        break;

        case 3 :
        printf("\n----- Decrescente -----\n");
        decrescente();
        break;

        default :
        printf("\n----- Valor Inválido! -----");
    }
}

gearle01 commented 5 years ago

`` Gearle Soares

include

define TAMANHO 100000

void merge(int vetor[], int inicio, int meio, int fim); void mergeSort(int vetor[], int inicio, int meio);

void MODA(long comp, long trocas, long tempo){ printf("Quantidade de comparações é: %ld \n", comp); printf("Quantidade de trocas é: %ld \n", trocas); printf("Tempo usado: %ld", tempo); printf("\n"); }long qutcompa, qtdtroca;

void main(){ printf("São 100.000 números gerados aleatoriamente\n"); long tempo1, tempo2, tempo3; int vetor1[TAMANHO], vetor2[TAMANHO], vetor3[TAMANHO]; //vetor com valor fixo clock_t tempoInicial, tempoFinal; //Variaveis para guardar o tempo de execucao srand(time(NULL)); //Cria uma semente para numeros aleatorios printf("-------------------------------------"); //------------------ VALORES ALEATORIOS-------------------------- tempoInicial = clock(); //contagem inicial do tempo for (int i = 0; i < TAMANHO; i++) vetor1[i] = rand() % 10; //Atribui valor aleatorio entre 0 e 9 //#Chama a função# mergeSort(vetor1, 0, TAMANHO - 1); printf("\n");

tempoFinal = clock(); //termina a contagem do tempo
tempo1 = tempoFinal - tempoInicial;
//calcula e mostra o tempo total de execucao
printf("Valores Aleatorios entre 0 e 9 \n");
MODA(qutcompa, qtdtroca, tempo1);
printf("-------------------------------------");
//------------------ VALORES CRESCENTES---------------------------
qutcompa = 0;
qtdtroca = 0;
tempoInicial = clock(); //contagem inicial do tempo
for (int i = 0; i < TAMANHO; i++)
    vetor2[i] = i+1; 
//#Chama a função#
mergeSort(vetor2, 0, TAMANHO - 1);
printf("\n");

tempoFinal = clock(); //termina a contagem do tempo
tempo2 = tempoFinal - tempoInicial;

printf("Valores Crescentes de 0 a 9 \n");
MODA(qutcompa, qtdtroca, tempo2);
printf("-------------------------------------");
//----------------- VALORES DECRESCENTES------------------------
qutcompa = 0;
qtdtroca = 0;
long count = TAMANHO;
tempoInicial = clock(); //contagem inicial do tempo
for (int i = 0; i < TAMANHO; i++){
    vetor3[i] = count; 
    count--;}
//#Chama a função#
mergeSort(vetor3, 0, TAMANHO - 1);
    printf("\n");
 tempoFinal = clock(); //termina a contagem do tempo
tempo3 = tempoFinal - tempoInicial;
    printf("Valores Decrescentes de 9 a 0  \n");
MODA(qutcompa, qtdtroca, tempo3);

} void merge(int vetor[], int inicio, int meio, int fim) { int i, j, k; int n1 = meio - inicio + 1; int n2 = fim - meio; int L[n1], R[n2];

        for (i = 0; i < n1; i++)
           L[i] = vetor[inicio + i];
         for (j = 0; j < n2; j++)
           R[j] = vetor[meio + 1 + j];
             i = 0;
             j = 0;
             k = inicio;
while (i < n1 && j < n2) {
    if (L[i] <= R[j]) {
        vetor[k] = L[i];
        i++;
    }else {
        vetor[k] = R[j];
        j++;
        qtdtroca++; }
        qutcompa++;
        k++;
}while (i < n1) {
    vetor[k] = L[i];
    i++;
    k++;
}while (j < n2) {
    vetor[k] = R[j];
    j++;
    k++; }
 }

void mergeSort(int vetor[], int inicio, int fim) { if (inicio < fim) { int m = inicio + (fim - inicio) / 2; mergeSort(vetor, inicio, m); mergeSort(vetor, m + 1, fim); merge(vetor, inicio, m, fim); } }

Samuel-Amaro commented 5 years ago

// Samuel Amaro Do Nascimento

include

include

include

include

define TAMANHO 1000

void merge(int vetor[], int inicio, int meio, int fim); void mergeSort(int vetor[], int inicio, int meio); //função preenche vetor void prenche(int vetor[],int tamanho,char tipo); int troca = 0, compara = 0;

void main() { int vetor[TAMANHO]; //vetor com tamanho definido clock_t tempoInicial, tempoFinal; //Variaveis para guardar o tempo de execucao srand(time(NULL)); //Cria uma semente para numeros aleatorios tempoInicial = clock(); //inicia contagem do tempo
prenche(vetor,TAMANHO,'d'); // c - crescente d - decrecente a - aleatorio
//Chama a fucao passando o vetor como parametro
mergeSort(vetor, 0, TAMANHO - 1);
//Mostra valores do vetor ordenado
for (int i = 0; i < TAMANHO; i++) {
    printf("%d\t", vetor[i]);
}
printf("\n");
tempoFinal = clock(); //finaliza contagem do tempo
//calcula e mostra o tempo total de execucao
printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC);
printf("Numero de trocas: %d numero de compara: %d\n",troca,compara);
}

/função que preenche vetor/ void prenche(int vetor[],int tamanho,char tipo) { int cont_cresce = 0, cont_decres = 1000; if(tipo == 'c') { //zera_vet(vetor,TAMANHO); printf("Valores não Ordenados\n"); for(int i = 0; i < TAMANHO; i += 1) { vetor[i] = cont_cresce += 1; printf("%d \t",vetor[i]); } printf("\n\n"); } if(tipo == 'd') { printf("Valores não Ordenados \n"); //zera_vet(vetor,TAMANHO); for(int i = 0; i < TAMANHO; i += 1) { vetor[i] = cont_decres -= 1; printf("%d \t",vetor[i]); } printf("\n\n"); } srand( time( NULL )); if(tipo == 'a') { printf("Valores não Ordenados \n"); //zera_vet(vetor,TAMANHO); for(int i = 0; i < TAMANHO; i += 1) { vetor[i] = rand() % 1000 + 1; printf("%d \t",vetor[i]); } printf("\n\n"); } } //função que ordena o vetor void merge(int vetor[], int inicio, int meio, int fim) { int i, j, k; int n1 = meio - inicio + 1; int n2 = fim - meio; int L[n1], R[n2]; for (i = 0; i < n1; i++) L[i] = vetor[inicio + i]; for (j = 0; j < n2; j++) R[j] = vetor[meio + 1 + j]; i = 0; j = 0; k = inicio; while (i < n1 && j < n2) { if (L[i] <= R[j]) { vetor[k] = L[i]; i++; //troca += 1;
    }

    else{
        vetor[k] = R[j];
        troca += 1;
        j++;
    }
     compara += 1;

    k++;
}
while (i < n1) {
    vetor[k] = L[i];
    //troca += 1;
    i++;
    k++;
    compara += 1;

}
while(j < n2) {
    vetor[k] = R[j];
    //troca += 1;
    j++;
    k++;
    compara += 1;

}
}

//função que quebra o vetor em partes ate não pode quebrara mais void mergeSort(int vetor[], int inicio, int fim) { if (inicio < fim) { int m = inicio + (fim - inicio) / 2; mergeSort(vetor, inicio, m); mergeSort(vetor, m + 1, fim); merge(vetor, inicio, m, fim); } }

Vanderson11 commented 5 years ago

Vanderson leite campos

include

define TAMANHO 100000

void merge(int vetor[], int inicio, int meio, int fim); void mergeSort(int vetor[], int inicio, int meio); void merge2(int vetor[], int inicio, int meio, int fim); void mergeSort2(int vetor[], int inicio, int meio); int compar=0,troca=0;

int aleatorio(){

 int vetor[TAMANHO]; 
 clock_t tempoInicial, tempoFinal; 
 srand(time(NULL)); 
 tempoInicial = clock(); 

 for (int i = 0; i < TAMANHO; i++) {
     vetor[i] = rand() % 10; 
 }

 for (int i = 0; i < TAMANHO; i++) {
     printf("%d\t", vetor[i]);
 }
 printf("\n");

 mergeSort(vetor, 0, TAMANHO - 1);

 for (int i = 0; i < TAMANHO; i++) {
     printf("%d\t", vetor[i]);
 }
 printf("\n");

 printf("As trocas:%d\n",troca);
 printf("As comparacoes:%d\n",compar);

 tempoFinal = clock(); 

 printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC);    

 }

int crescente(){

 int vetor[TAMANHO]; 
 clock_t tempoInicial, tempoFinal; 
 srand(time(NULL)); 
 tempoInicial = clock(); 

 for (int i = 0; i < TAMANHO; i++) {
     vetor[i] = i; 
 }

 for (int i = 0; i < TAMANHO; i++) {
     printf("%d\t", vetor[i]);
 }
 printf("\n");

 mergeSort(vetor, 0, TAMANHO - 1);

 for (int i = 0; i < TAMANHO; i++) {
     printf("%d\t", vetor[i]);
 }
 printf("\n");

 printf("As trocas:%d\n",troca);
 printf("As comparacoes:%d\n",compar);

 tempoFinal = clock(); 

 printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC);        

 }

int decrescente(){

 int vetor[TAMANHO]; 
 clock_t tempoInicial, tempoFinal; 
 srand(time(NULL)); 
 tempoInicial = clock(); 

 for (int i = 0; i < TAMANHO; i++) {
     vetor[i] = TAMANHO - i; 
 }

 for (int i = 0; i < TAMANHO; i++) {
     printf("%d\t", vetor[i]);
 }
 printf("\n");

 mergeSort(vetor, 0, TAMANHO - 1);

 for (int i = 0; i < TAMANHO; i++) {
     printf("%d\t", vetor[i]);
 }
 printf("\n");

 printf("As trocas:%d\n",troca);
 printf("As comparacoes:%d\n",compar);

 tempoFinal = clock(); 

 printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC);    

 }

void main() {

int x;
printf("1 - Aleatorio\n");
printf("2 - Crescente\n");
printf("3 - Decrescente\n");
printf("Escolha uma opcao:");
scanf("%d",&x);
printf("\n");

switch(x){
        case 1:
               aleatorio(); 
             break;

        case 2:
               crescente();
             break;
        case 3:
               decrescente();             
             break;  

}

}

void merge(int vetor[], int inicio, int meio, int fim) {

int i, j, k;
int n1 = meio - inicio + 1;
int n2 = fim - meio;
int vetorEsquerda[n1], vetorDireita[n2];
for (i = 0; i < n1; i++)
    vetorEsquerda[i] = vetor[inicio + i];
for (j = 0; j < n2; j++)
    vetorDireita[j] = vetor[meio + 1 + j];
i = 0;
j = 0;
k = inicio;
while (i < n1 && j < n2) {
    if (vetorEsquerda[i] <= vetorDireita[j]) {
        compar++;
        vetor[k] = vetorEsquerda[i];
        i++;
    }
    else {//troca
        troca++;    
        vetor[k] = vetorDireita[j];
        j++;
    }
    k++;
}
while (i < n1) {
    vetor[k] = vetorEsquerda[i];
    i++;
    k++;
}

while (j < n2) {
    vetor[k] = vetorDireita[j];
    j++;
    k++;
}

}

void mergeSort(int vetor[], int inicio, int fim) {

    if (inicio < fim) {
    int m = inicio + (fim - inicio) / 2;
    mergeSort(vetor, inicio, m);
    mergeSort(vetor, m + 1, fim);
    merge(vetor, inicio, m, fim);
}

}

MatheusMagga commented 5 years ago

// Matheus de Almeida Magalhães

include

define TAMANHO 100000

void merge(int vetor[], int inicio, int meio, int fim); void mergeSort(int vetor[], int inicio, int meio); int qComp = 0, qTroc = 0; void main() {

int vetor[TAMANHO], esc = 0;      //vetor com tamanho definido
clock_t tempoInicial, tempoFinal; //Variaveis para guardar o tempo de execucao
srand(time(NULL));                //Cria uma semente para numeros aleatorios
tempoInicial = clock();           //inicia contagem do tempo

printf("Aleatório(1) Crescente(2) Decrescente(3)");
scanf("%d", &esc);

if (esc == 1)
{

    for (int i = 0; i < TAMANHO; i++)
    {
        vetor[i] = rand() % 10;
    }
}
else if (esc == 2)
{

    for (int i = 0; i < TAMANHO; i++)
    {
        vetor[i] = i + 1;
    }
}
else if (esc == 3)
{

    for (int i = 0; i < TAMANHO; i++)
    {
        vetor[i] = TAMANHO - i;
    }
}
else
{

    printf("Não indentificado!");
}
//Chama a fucao passando o vetor como parametro
mergeSort(vetor, 0, TAMANHO - 1);

printf("Quntidade de comparações: %d\nQuntidade de trocas: %d\n", qComp, qTroc);
tempoFinal = clock(); //finaliza contagem do tempo
//calcula e mostra o tempo total de execucao
printf("Tempo: %f s\n", (double)(tempoFinal - tempoInicial) / CLOCKS_PER_SEC);

}

void merge(int vetor[], int inicio, int meio, int fim) {

int i, j, k;
int n1 = meio - inicio + 1;
int n2 = fim - meio;
int L[n1], R[n2];

for (i = 0; i < n1; i++)
    L[i] = vetor[inicio + i];
for (j = 0; j < n2; j++)
    R[j] = vetor[meio + 1 + j];
i = 0;
j = 0;
k = inicio;
while (i < n1 && j < n2)
{

    if (L[i] <= R[j])
    {
        vetor[k] = L[i];
        i++;

        qComp++;
    }
    else
    {
        vetor[k] = R[j];
        j++;

        qTroc++;
    }
    k++;
}
while (i < n1)
{
    vetor[k] = L[i];
    i++;
    k++;
}

while (j < n2)
{
    vetor[k] = R[j];
    j++;
    k++;
}

}

dyegolv commented 5 years ago

Dyego Rodrigues F. de Lima

 #include<stdlib.h>
 #include <stdio.h>
 #include <time.h>
 #include <stdlib.h>
 #define TAMANHO 10

 void merge(int vetor[], int inicio, int meio, int fim);
 void mergeSort(int vetor[], int inicio, int meio); 
 int troc, comp = 0; // Contador do aleatorio

 int aleatorio() {
    int vetor[TAMANHO]; //vetor com tamanho definido
    clock_t tempoInicial, tempoFinal; //Variaveis para guardar o tempo de execucao
    srand(time(NULL)); //Cria uma semente para numeros aleatorios
    tempoInicial = clock(); //inicia contagem do tempo
    for (int i = 0; i < TAMANHO; i++) {
        vetor[i] = rand() % 10; //Atribui um inteiro aleatorio entre 0 e 9
        }

 //Chama a fucao passando o vetor como parametro
    mergeSort(vetor, 0, TAMANHO - 1);

 //Mostra valores do vetor ordenado
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\n");
    printf("\nComparacao: %d", comp);
    printf("\nTroca: %d", troc);
    printf("\n");
    tempoFinal = clock(); //finaliza contagem do tempo
    //calcula e mostra o tempo total de execucao
    printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC);

    mergeSort(vetor, 0, TAMANHO - 1);
    printf("\n");

        for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
 }

 int crescente() {
    int vetor[TAMANHO]; //vetor com tamanho definido
    clock_t tempoInicial, tempoFinal; //Variaveis para guardar o tempo de execucao
    tempoInicial = clock(); //inicia contagem do tempo
    for (int i = 0; i < TAMANHO; i++) {
        vetor[i] = i; //Atribui um inteiro aleatorio entre 0 e 9
    }
    printf("\n");
    //Chama a fucao passando o vetor como parametro
    mergeSort(vetor, 0, TAMANHO - 1);
    //Mostra valores do vetor ordenado   
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\n");
    printf("\nComparacao: %d", comp);
    printf("\nTroca: %d", troc);
    printf("\n");
    tempoFinal = clock(); //finaliza contagem do tempo
    //calcula e mostra o tempo total de execucao
    printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC);
}

int decrescente() {
    int vetor[TAMANHO]; //vetor com tamanho definido
    clock_t tempoInicial, tempoFinal; //Variaveis para guardar o tempo de execucao
    tempoInicial = clock(); //inicia contagem do tempo
    for (int i = 0; i < TAMANHO; i++) {
        vetor[i] = TAMANHO - i; //Atribui um inteiro aleatorio entre 0 e 9
    }
     for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\n");
    //Chama a fucao passando o vetor como parametro
    mergeSort(vetor, 0, TAMANHO - 1);
    //Mostra valores do vetor ordenado   
    for (int i = 0; i < TAMANHO; i++) {
        printf("%d\t", vetor[i]);
    }
    printf("\n");
    printf("\nComparacao: %d", comp);
    printf("\nTroca: %d", troc);
    printf("\n");
    tempoFinal = clock(); //finaliza contagem do tempo
    //calcula e mostra o tempo total de execucao
    printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC);
}

 void merge(int vetor[], int inicio, int meio, int fim) {
 int i, j, k;
 int n1 = meio - inicio + 1;
 int n2 = fim - meio;
 int L[n1], R[n2];
 for (i = 0; i < n1; i++)
 L[i] = vetor[inicio + i];
 for (j = 0; j < n2; j++)
 R[j] = vetor[meio + 1 + j];
 i = 0;
 j = 0;
 k = inicio;
 while (i < n1 && j < n2) {
 if (L[i] <= R[j]) {
 vetor[k] = L[i];
 i++;
 }
 else {
 vetor[k] = R[j];
 j++;
 troc = troc + 1;
 }
 comp = comp + 1;
k++;

 }
 while (i < n1) {
 vetor[k] = L[i];
 i++;
 k++;
 }

 while (j < n2) {
 vetor[k] = R[j];
 j++;
 k++;
 }
 }

 void mergeSort(int vetor[], int inicio, int fim) {
 if (inicio < fim) {
 int m = inicio + (fim - inicio) / 2;
 mergeSort(vetor, inicio, m);
 mergeSort(vetor, m + 1, fim);
 merge(vetor, inicio, m, fim);
 }
 }

 int main() {
    int opcao = 0;
    printf("1 para aleatorio\t 2 para crescente\t 3 para descrescente\t\n");
    scanf("%d", &opcao);
    switch (opcao) {
        case 1:
        aleatorio();
        break;
        case 2:
        crescente();
        break;
        case 3:
        decrescente();
        break;
    }
    return 0;
 }

jvitor7085 commented 5 years ago

//José Vitor

include

define TAMANHO 100000

void main() { int vetor[TAMANHO]; int e1=0,e2=0,e3=0;//eleitos int j = 0,b =0,c=0,e=0; int tAleatorio=0; int tCrescente=0; int tDecrescente=0; int comp1=0;//aleatorio int comp2=0;//crescente int comp3=0;//decrescente clock_t tempoInicial, tempoFinal; srand(time(NULL)); tempoInicial = clock();

for (int i = 0; i < TAMANHO; i++) {
    vetor[i] = rand() % 100;
}

printf("\n");

for (int i = 1; i < TAMANHO; i++) {
    e1 = vetor[i];
    j = i - 1;comp1++;
    while (j >= 0 && vetor[j] > e1) {
        vetor[j + 1] = vetor[j];
        j--;tAleatorio++;comp1++;
    }
    vetor[j + 1] = e1;
}

//declarei a variavel 'a' no lugar de 'i' e a variavel 'b' no lugar de 'j'..
for (int a = 0; a < TAMANHO; a++) {
    e2 = vetor[a];
    b = a - 1;comp2++;
    while (b >= 0 && vetor[b] > e2) {
        vetor[b - 1] = vetor[b];
        b++,tCrescente;comp2++;
        for(a=TAMANHO;a>0;a--){
            printf("%d\n",vetor[b]);
        }

    }}

     for(int d=0;d<TAMANHO;d++){
        e3 = vetor[d];
    e = d - 1;comp3++;
    while (e >= 0 && vetor[e] > e3) {
        vetor[e - 1] = vetor[e];
        d++,tDecrescente++;comp3++;
    }}

tempoFinal = clock();
printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC);
printf("\n\numero de troca de aleatorio para crescente=%d\n",tAleatorio);
printf("\n numero de comparacoes aleatorio=%d\n\n",comp1);

printf("\n numero troca de crescente para crescente=%d\n",tCrescente);
printf("\n n de comparacoes crescente=%d\n\n",comp2);

printf("\n numero de trocas de decrescente para crescente=%d\n",tDecrescente);
printf("\n numero de comparacoes decrescente=%d\n",comp3);

}

lucastakashi commented 5 years ago

Nome: Lucas Oliveira Neves

include

define TAMANHO 100000

void merge(int vetor[], int inicio, int meio, int fim); void mergeSort(int vetor[], int inicio, int meio); int qCompa = 0, qTroca = 0; void main() {

int vetor[TAMANHO], opc = 0;
clock_t tempoInicial, tempoFinal; srand(time(NULL));
tempoInicial = clock();

printf("Aleatório(1) Crescente(2) Decrescente(3)"); scanf("%d", &opc);

if (opc == 1) {

for (int i = 0; i < TAMANHO; i++)
{
    vetor[i] = rand() % 10;
}

} else if (opc == 2) {

for (int i = 0; i < TAMANHO; i++)
{
    vetor[i] = i + 1;
}

} else if (opc == 3) {

for (int i = 0; i < TAMANHO; i++)
{
    vetor[i] = TAMANHO - i;
}

} else {

printf("Não identifiquei!");

} //Chama a fucao passando o vetor como parametro mergeSort(vetor, 0, TAMANHO - 1);

printf("Quntidade de comparações: %d\nQuntidade de trocas: %d\n", qCompa, qTroca); tempoFinal = clock(); printf("Tempo: %f s\n", (double)(tempoFinal - tempoInicial) / CLOCKS_PER_SEC); }

void merge(int vetor[], int inicio, int meio, int fim) {

int i, j, k; int n1 = meio - inicio + 1; int n2 = fim - meio; int L[n1], R[n2];

for (i = 0; i < n1; i++) L[i] = vetor[inicio + i]; for (j = 0; j < n2; j++) R[j] = vetor[meio + 1 + j]; i = 0; j = 0; k = inicio; while (i < n1 && j < n2) {

if (L[i] <= R[j])
{
    vetor[k] = L[i];
    i++;

    qCompa++;
}
else
{
    vetor[k] = R[j];
    j++;

    qTroca++;
}
k++;

} while (i < n1) { vetor[k] = L[i]; i++; k++; }

while (j < n2) { vetor[k] = R[j]; j++; k++; } }

include

define TAMANHO 100000

void merge(int vetor[], int inicio, int meio, int fim); void mergeSort(int vetor[], int inicio, int meio); int qCompa = 0, qTroca = 0; void main() {

int vetor[TAMANHO], opc = 0;
clock_t tempoInicial, tempoFinal; srand(time(NULL));
tempoInicial = clock();

printf("Aleatório(1) Crescente(2) Decrescente(3)"); scanf("%d", &opc);

if (opc == 1) {

for (int i = 0; i < TAMANHO; i++)
{
    vetor[i] = rand() % 10;
}

} else if (opc == 2) {

for (int i = 0; i < TAMANHO; i++)
{
    vetor[i] = i + 1;
}

} else if (opc == 3) {

for (int i = 0; i < TAMANHO; i++)
{
    vetor[i] = TAMANHO - i;
}

} else {

printf("Não identifiquei!");

} //Chama a fucao passando o vetor como parametro mergeSort(vetor, 0, TAMANHO - 1);

printf("Quntidade de comparações: %d\nQuntidade de trocas: %d\n", qCompa, qTroca); tempoFinal = clock(); printf("Tempo: %f s\n", (double)(tempoFinal - tempoInicial) / CLOCKS_PER_SEC); }

void merge(int vetor[], int inicio, int meio, int fim) {

int i, j, k; int n1 = meio - inicio + 1; int n2 = fim - meio; int L[n1], R[n2];

for (i = 0; i < n1; i++) L[i] = vetor[inicio + i]; for (j = 0; j < n2; j++) R[j] = vetor[meio + 1 + j]; i = 0; j = 0; k = inicio; while (i < n1 && j < n2) {

if (L[i] <= R[j])
{
    vetor[k] = L[i];
    i++;

    qCompa++;
}
else
{
    vetor[k] = R[j];
    j++;

    qTroca++;
}
k++;

} while (i < n1) { vetor[k] = L[i]; i++; k++; }

while (j < n2) { vetor[k] = R[j]; j++; k++; } }

Tainara-Ataides commented 5 years ago

Nome: Tainara Moura De Ataídes

include

define TAMANHO 100000

void merge(int vetor[], int inicio, int meio, int fim); void mergeSort(int vetor[], int inicio, int meio);

void main() { int vetor[TAMANHO]; //vetor com tamanho definido int comparacao; int troca; clock_t tempoInicial, tempoFinal; //Variaveis para guardar o tempo de execucao srand(time(NULL)); //Cria uma semente para numeros aleatorios tempoInicial = clock(); //inicia contagem do tempo for (int i = 0; i < TAMANHO; i++) { vetor[i] = rand() % 100000; //Atribui um inteiro aleatorio entre 0 e 9 } //Mostra valores do vetor nao ordenado for (int i = 0; i < TAMANHO; i++) { printf("%d\t", vetor[i]); } printf("\n"); //Chama a fucao passando o vetor como parametro mergeSort(vetor, 0, TAMANHO - 1); //Mostra valores do vetor ordenado
for (int i = 0; i < TAMANHO; i++) { printf("%d\t", vetor[i]); } printf("\n"); tempoFinal = clock(); //finaliza contagem do tempo //calcula e mostra o tempo total de execucao printf("Tempo: %f s\n", (double) (tempoFinal - tempoInicial) / CLOCKS_PER_SEC); }

void merge(int vetor[], int inicio, int meio, int fim) { int i, j, k; int n1 = meio - inicio + 1; int n2 = fim - meio; int vetorEsquerda[n1], vetorDireita[n2]; for (i = 0; i < n1; i++) vetorEsquerda[i] = vetor[inicio + i]; for (j = 0; j < n2; j++) vetorDireita[j] = vetor[meio + 1 + j]; i = 0; j = 0; k = inicio; while (i < n1 && j < n2) { if (vetorEsquerda[i] <= vetorDireita[j]) { vetor[k] = vetorEsquerda[i]; i++; } else {//troca vetor[k] = vetorDireita[j]; j++; } k++; } while (i < n1) { vetor[k] = vetorEsquerda[i]; i++; k++; }

while (j < n2) {
    vetor[k] = vetorDireita[j];
    j++;
    k++;
}

}

void mergeSort(int vetor[], int inicio, int fim) { if (inicio < fim) {//condicao de parada int m = inicio + (fim - inicio) / 2;//posicao para dividir o vetor mergeSort(vetor, inicio, m);//chamada recursiva para a metade esquerda mergeSort(vetor, m + 1, fim);//chamada recursiva para a metade direita merge(vetor, inicio, m, fim); } }