C/Visual C - Ordenamientos

 
Vista:

Ordenamientos

Publicado por Adrian (4 intervenciones) el 15/04/2001 17:44:01
Necesitaria (y con esto creo terminar todas las consultas, disculpen un finde tan molesto) los algoritmos de ordenamiento "por intercambio de residuos" y "cuenta de distribuciones", ambos en C. Algo sencillo, para ordenar un vector de enteros, yo despues lo adapto.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Algoritmos de ordenamiento por intercambio de residuos y cuenta de distribuciones en C

Publicado por Alejandro (913 intervenciones) el 20/09/2024 18:24:43
¡Claro! Aquí tienes los algoritmos de ordenamiento "por intercambio de residuos" (Radix sort) y "cuenta de distribuciones" (Counting sort) en C para ordenar un vector de enteros:

1. Algoritmo de ordenamiento por intercambio de residuos (Radix sort):

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
#include <stdio.h>
 
// Función para obtener el máximo elemento del vector
int getMax(int arr[], int n) {
    int max = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr > max) {
            max = arr;
        }
    }
    return max;
}
 
// Función para realizar el ordenamiento por intercambio de residuos
void radixSort(int arr[], int n) {
    int max = getMax(arr, n);
 
    // Realizar el ordenamiento por cada dígito
    for (int exp = 1; max / exp > 0; exp *= 10) {
        int output[n]; // Vector de salida
        int count[10] = {0}; // Vector de conteo para cada dígito
 
        // Contar la frecuencia de cada dígito
        for (int i = 0; i < n; i++) {
            count[(arr / exp) % 10]++;
        }
 
        // Calcular las posiciones actuales de los elementos
        for (int i = 1; i < 10; i++) {
            count[i] += count[i - 1];
        }
 
        // Construir el vector de salida
        for (int i = n - 1; i >= 0; i--) {
            output[count[(arr[i] / exp) % 10] - 1] = arr[i];
            count[(arr[i] / exp) % 10]--;
        }
 
        // Copiar el vector de salida al vector original
        for (int i = 0; i < n; i++) {
            arr[i] = output[i];
        }
    }
}
 
// Función para imprimir el vector
void printArray(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}
 
int main() {
    int arr[] = {170, 45, 75, 90, 802, 24, 2, 66};
    int n = sizeof(arr) / sizeof(arr[0]);
 
    printf("Vector original: ");
    printArray(arr, n);
 
    radixSort(arr, n);
 
    printf("Vector ordenado: ");
    printArray(arr, n);
 
    return 0;
}

2. Algoritmo de ordenamiento por cuenta de distribuciones ([i]Counting sort
):

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
#include <stdio.h>
 
// Función para realizar el ordenamiento por cuenta de distribuciones
void countingSort(int arr[], int n) {
    int max = arr[0];
    int min = arr[0];
 
    // Encontrar el valor máximo y mínimo en el vector
    for (int i = 1; i < n; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
        if (arr[i] < min) {
            min = arr[i];
        }
    }
 
    int range = max - min + 1; // Rango de valores
 
    int count[range] = {0}; // Vector de conteo para cada valor
    int output[n]; // Vector de salida
 
    // Contar la frecuencia de cada valor
    for (int i = 0; i < n; i++) {
        count[arr[i] - min]++;
    }
 
    // Calcular las posiciones actuales de los elementos
    for (int i = 1; i < range; i++) {
        count[i] += count[i - 1];
    }
 
    // Construir el vector de salida
    for (int i = n - 1; i >= 0; i--) {
        output[count[arr[i] - min] - 1] = arr[i];
        count[arr[i] - min]--;
    }
 
    // Copiar el vector de salida al vector original
    for (int i = 0; i < n; i++) {
        arr[i] = output[i];
    }
}
 
// Función para imprimir el vector
void printArray(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}
 
int main() {
    int arr[] = {4, 2, 2, 8, 3, 3, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
 
    printf("Vector original: ");
    printArray(arr, n);
 
    countingSort(arr, n);
 
    printf("Vector ordenado: ");
    printArray(arr, n);
 
    return 0;
}

Estos son ejemplos sencillos de los algoritmos de ordenamiento por intercambio de residuos ([i]Radix sort
) y cuenta de distribuciones ([i]Counting sort
) en C. Puedes adaptarlos según tus necesidades y el tipo de datos que desees ordenar.

Espero que estos ejemplos te sean útiles. ¡Buena suerte, Adrián!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar