EP---Introduction-to-Computing/complemento.c at main · thaliaangelo/EP---Introduction-to-Computing · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
void selection(int *V, int n){
    /**
    *Ordena uma lista, comparando um elementos com todos, o que a cada comparação
    *completa o menor elemento estará próximo ao começo da lista.
    *Entradas: Uma lista desordenada e sua quantidade de elementos.
    *Saída: Vazia.
    */

    for (int i = 0; i < (n - 1); i++){
        for (int j = i + 1; j < n; j++){
            if (V[i] > V[j]){
                int sup = V[i];
                V[i] = V[j];
                V[j] = sup;
            }
        }
    }
}

void bubble(int *V, int n){
    /**
    *Ordena uma lista, comparando dois a dois elementos, o que a cada comparação
    *completa o maior elemento estará próximo ao final da lista.
    *Entradas: Uma lista desordenada e sua quantidade de elementos.
    *Saída: Vazia.
    */

    for (int i = 0; i < n; i++){
        for (int j = 0; j < (n - 1); j++){
            if (V[j] > V[j + 1]){
                int sup = V[j];
                V[j] = V[j + 1];
                V[j + 1] = sup;
            }
        }
    }
}

void insertion(int *V, int n){
    /**
    *Ordena uma lista, comparando dois a dois elementos, o que a cada dois elementos trocados
    *compara do índice atual até o índice 0, ordenando até o índice atual.
    *Entradas: Uma lista desordenada e sua quantidade de elementos.
    *Saída: Vazia.
    */

    for (int i = 0; i < (n - 1); i++){
        if (V[i] > V[i + 1]){
            int sup = V[i + 1];
            V[i + 1] = V[i];
            V[i] = sup;
            for(int t = i; t > 0; t--){
                if (V[t - 1] > V[t]){
                    int sup_menor = V[t];
                    V[t] = V[t - 1];
                    V[t - 1] = sup_menor;
                }
            }
        }
    }

}

void counting(int *V, int n){
    /**
    *Ordena uma lista, em que, a cada elemento encontrado na lista dada, incrementa
    *+1 em seu índice. Após isso, cria uma nova lista adicionando, em ordem crescente
    *a quantidade de vezes que um certo índice ocorre.
    *Entradas: Uma lista desordenada e sua quantidade de elementos.
    *Saída: Vazia.
    */

    int maior = V[0];
    for (int i = 0; i < n; i++){
        if (V[i] > maior){
            maior = V[i];
        }
    }

    int W[maior + 1];
    for (int i = 0; i < (maior + 1); i++){
        W[i] = 0;
    }

    for (int i = 0; i < n; i++){
        int x = V[i];
        W[x]++;
    }

    int t = 0;
    for (int i = 0; i < (maior + 1); i++){
        for (int j = W[i]; j > 0; j--){
            V[t] = i;
            t++;
        }
    }

}