como clasificar

En C, puedes clasificar elementos de un arreglo utilizando un algoritmo de ordenamiento. Aquí te presento algunos de los más comunes:

### 1. Ordenamiento por Selección (Selection Sort)

Este algoritmo funciona seleccionando el elemento más pequeño del arreglo y colocándolo en la posición correcta.

```c
#include <stdio.h>

void ordenar(int arreglo[], int tam) {
    int i, j, min, aux;

    for (i = 0; i < tam - 1; i++) {
        min = i;
        for (j = i + 1; j < tam; j++) {
            if (arreglo[j] < arreglo[min]) {
                min = j;
            }
        }
        if (min != i) {
            aux = arreglo[i];
            arreglo[i] = arreglo[min];
            arreglo[min] = aux;
        }
    }
}

int main() {
    int arreglo[] = {64, 34, 25, 12, 22, 11, 90};
    int tam = sizeof(arreglo) / sizeof(arreglo[0]);

    printf("Arreglo original: ");
    for (int i = 0; i < tam; i++) {
        printf("%d ", arreglo[i]);
    }
    printf("\n");

    ordenar(arreglo, tam);

    printf("Arreglo ordenado: ");
    for (int i = 0; i < tam; i++) {
        printf("%d ", arreglo[i]);
    }
    printf("\n");

    return 0;
}
```

### 2. Ordenamiento por Inserción (Insertion Sort)

Este algoritmo funciona insertando cada elemento en su posición correcta dentro del arreglo ya ordenado.

```c
#include <stdio.h>

void ordenar(int arreglo[], int tam) {
    int i, j, aux;

    for (i = 1; i < tam; i++) {
        aux = arreglo[i];
        j = i - 1;
        while (j >= 0 && arreglo[j] > aux) {
            arreglo[j + 1] = arreglo[j];
            j--;
        }
        arreglo[j + 1] = aux;
    }
}

int main() {
    int arreglo[] = {64, 34, 25, 12, 22, 11, 90};
    int tam = sizeof(arreglo) / sizeof(arreglo[0]);

    printf("Arreglo original: ");
    for (int i = 0; i < tam; i++) {
        printf("%d ", arreglo[i]);
    }
    printf("\n");

    ordenar(arreglo, tam);

    printf("Arreglo ordenado: ");
    for (int i = 0; i < tam; i++) {
        printf("%d ", arreglo[i]);
    }
    printf("\n");

    return 0;
}
```

### 3. Ordenamiento por Mezcla (Merge Sort)

Este algoritmo funciona dividiendo el arreglo en dos partes, ordenando cada parte y luego mezclando las dos partes ordenadas.

```c
#include <stdio.h>

void ordenar(int arreglo[], int tam) {
    int medio = tam / 2;
    int izquierda[tam];
    int derecha[tam];

    for (int i = 0; i < medio; i++) {
        izquierda[i] = arreglo[i];
    }
    for (int i = medio; i < tam; i++) {
        derecha[i - medio] = arreglo[i];
    }

    ordenar(izquierda, medio);
    ordenar(derecha, tam - medio);

    mezclar(izquierda, derecha, tam);
}

void mezclar(int izquierda[], int derecha[], int tam) {
    int i = 0, j = 0, k = 0;
    int arreglo[tam];

    while (i < tam / 2 && j < tam / 2) {
        if (izquierda[i] < derecha[j]) {
            arreglo[k] = izquierda[i];
            i++;
        } else {
            arreglo[k] = derecha[j];
            j++;
        }
        k++;
    }

    while (i < tam / 2) {
        arreglo[k] = izquierda[i];
        i++;
        k++;
    }

    while (j < tam / 2) {
        arreglo[k] = derecha[j];
        j++;
        k++;
    }

    for (int i = 0; i < tam; i++) {
        arreglo[i] = izquierda[i];
    }
}

int main() {
    int arreglo[] = {64, 34, 25, 12, 22, 11, 90};
    int tam = sizeof(arreglo) / sizeof(arreglo[0]);

    printf("Arreglo original: ");
    for (int i = 0; i < tam; i++) {
        printf("%d ", arreglo[i]);
    }
    printf("\n");

    ordenar(arreglo, tam);

    printf("Arreglo ordenado: ");
    for (int i = 0; i < tam; i++) {
        printf("%d ", arreglo[i]);
    }
    printf("\n");

    return 0;
}
```

### 4. Ordenamiento por Burbuja (Bubble Sort)

Este algoritmo funciona comparando cada par de elementos adyacentes y intercambiándolos si están en orden incorrecto.

```c
#include <stdio.h>

void ordenar(int arreglo[], int tam) {
    int i, j, aux;

    for (i = 0; i < tam - 1; i++) {
        for (j = 0; j < tam - i - 1; j++) {
            if (arreglo[j] > arreglo[j + 1]) {
                aux = arreglo[j];
                arreglo[j] = arreglo[j + 1];
                arreglo[j + 1] = aux;
            }
        }
    }
}

int main() {
    int arreglo[] = {64, 34, 25, 12, 22, 11, 90};
    int tam = sizeof(arreglo) / sizeof(arreglo[0]);

    printf("Arreglo original: ");
    for (int i = 0; i < tam; i++) {
        printf("%d ", arreglo[i]);
    }
    printf("\n");

    ordenar(arreglo, tam);

    printf("Arreglo ordenado: ");
    for (int i = 0; i < tam; i++) {
        printf("%d ", arreglo[i]);
    }
    printf("\n");

    return 0;
}
```

Recuerda que cada algoritmo tiene su propia complejidad de tiempo y espacio, por lo que debes elegir el que mejor se adapte a tus necesidades.