Buscador Elinv.

Búsqueda personalizada

domingo, 3 de abril de 2011

Estructuras anidadas. Todo lo que tienes que saber por Elinv.

:arrow: Hola, a pedido de una jóven, hemos realizado este código que creo interesará y solucionará muchas dudas respecto de las estructuras anidadas, principalmente cuando la estructura secundaria anidada, a su vez tiene múltiples elementos.

:arrow: Bueno en este proyecto que puedes bajarte de aquí y que ha sido probado exitosamente en DEV C++ y CODE BLOCK, aprenderemos lo siguiente.

:arrow: Como ingresar en forma automática información a estructuras anidadas.
:arrow: Como ingresar y/o editar en la misma función elementos de esas estructuras.
:arrow: Como imprimir en una sola función, por múltiples parámetros y formas, utilizando para ello otras sub estructuras para un mejor entendimiento del código.
:arrow: Como ordenar en una sola función, por distintos campos de la estructura primaria o de la anidada, también organizada la ordenación a través de estructuras.
:arrow: Como grabar en disco la estructura y como recuperarla, muy fácil, todo.
:arrow: Bueno aquí les dejo el código, que por supuesto es mejorable:
:arrow: --------------------------------------------------------------------------


/*
* Codigo desarrollado por Elinv.
* http://www.bragadomas.com/forodeprogramacion/index.php
* http://www.bragadomas.com
* http://www.bragadomas.com.ar
* http://luispedromendez.blogspot.com/
* http://elinv-elinv.blogspot.com/?expref=next-blog
*/

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>

//Cantidades de equipos y de jugadores
//Debe coincidir con la cantidad definidas en las estructuras
int equipos_cant = 5;
int jugadores_cant = 11;

//Estructuras anidadas secundaria primero
//y principal despues
//--------------------
struct jugadores
{
    char nombre[30];
    int dni;
    int edad;
    int goles;
    int amarillas;
    int rojas;
};

struct equipo
{
    char nombre[30];
    long int puntos;
    char barrio[30];
    struct jugadores team[11];
} orden_lectura;

struct equipo orden[5];
//Fin de la estructura principal.
//------------------------------
/*Estructura para clarificar mas el tipo de impresion
<Otra forma mas clara de desarrollar el codigo>*/
struct Tipo_Impresion
{
    int Por_equipos_solamente;
    int Por_equipos_y_jugadores;
    int Por_equipos_y_jugadores_goles;
    int Por_equipos_y_jugadores_sanciones;
} Imprimiendo = {1,2,3,4};
//------------------------------
/*Estructura para clarificar mas el tipo de ordenamiento
<Forma mas clara de desarrollar el codigo>*/
struct Tipo_de_Orden
{
    int por_equipo;
    int por_puntos_por_equipo;
    int por_jugador;
    int por_edad;
    int por_goles;
} Ordenando = {1,2,3,4,5};
//------------------------------
//Prototipos de funciones
//Para cargar equipos y jugadores
void cargar_equipos_y_jugadores(struct equipo orden[]);
//Para realizar informes.
void mostrar_equipos_y_jugadores(struct equipo orden[], int opciones);
//Para averiguar cuantos equipos cargados hay
int cuantos_equipos_cargados_hay(struct equipo orden[]);
//Para averiguar cuantos jugadores cargados hay en un equipo determinado
int cuantos_jugadores_cargados_hay(struct equipo orden[], int idequipo);
//Cargar manualmente un equipo
void cargar_equipos_manual(struct equipo orden[], int indice);
//Cargar manuelmente un jugador
void cargar_jugadores_manual(struct equipo orden[], int indice_equipo, int indice_jugador);
//Funcion para ordenar por diversos parametros.
void ordenar_de_menor_a_mayor(struct equipo orden[], int elementos, int opcion);
//Funcion para guardar en disco la estructura
void guardar_estructura(struct equipo orden[]);
//Funcion para leer la estructura
void leer_estructura(struct equipo orden[]);

//Procedimiento principal.
int main()
{

    int n;
    do
    {
        system("CLS");
        printf (" Menu ");
        printf (" \n-------INGRESOS-------------\n");
        printf (" 1. Ingresar Equipos y jugadores forma automatica\n");
        printf (" 2. Ingresar y/o editar Equipos\n");
        printf (" 3. Ingresar y/o editar Jugadores\n");
        printf (" \n-------VISTAS-------------\n");
        printf (" 4. Imprimir Equipos solamente\n");
        printf (" 5. Imprimir Equipos y Jugadores\n");
        printf (" 6. Imprimir Equipos, Jugadores y Goles\n");
        printf (" 7. Imprimir Equipos, Jugadores y Sanciones\n");
        printf (" 8. Imprimir Cuantos equipos hay actualmente cargados\n");
        printf (" 9. Imprimir Cuantos jugadores cargados tiene un equipo determinado\n");
        printf (" \n-------ORDENAMIENTO---------\n");
        printf (" 10. Ordenar por Equipo\n");
        printf (" 11. Ordenar por Puntos por Equipo\n");
        printf (" 12. Ordenar por Jugador\n");
        printf (" 13. Ordenar por Edad\n");
        printf (" 14. Ordenar por Goles\n");
        printf (" -------ENTRADA/SALIDA-----\n");
        printf (" 15. Grabar Equipos\n");
        printf (" 16. Leer Base de Datos\n");
        printf (" ----------------------------\n");
        printf (" 17. Salir\n");
        printf ("Ingrese una Opcion: ");
        scanf("%d",&n);
        if (n==1)
        {
//Ingresamos en forma automatica 2 equipos y dos jugadores por cada equipo
            system("CLS");
            cargar_equipos_y_jugadores(orden);
            printf("\n");
            system("PAUSE");
        }
        if (n==2)
        {
            system("CLS");
//Ingresar nuevo equipo o editar uno registrado
            char pregunta;
            int idequipo = cuantos_equipos_cargados_hay(orden);
            if (idequipo==0)
            {
                printf("\nAun no hay Equipos cargados\n");
                idequipo++;
                system("PAUSE");
            }
            if (idequipo <= equipos_cant)
            {
                printf("\nIngrese el Id del equipo a editar o crear, sera: %d, espacio disponible en la base.\n", idequipo);
            }
            else
            {
                printf("\nLa base de datos esta llena, ha llegado a su limite de %d registros.\n", equipos_cant);
            }
            printf ("\n\nDesea Aceptar este ID o ingresar usted uno disponible entre 1 y %d, ? s/n:\n", equipos_cant);
            fflush(stdin);
            scanf ("%c",&pregunta);
            if (tolower(pregunta)!='s')
            {
                fflush(stdin);
                scanf ("%d",&idequipo);
            }
            printf("\n");
            cargar_equipos_manual(orden, idequipo-1);
            printf("\n");
            system("PAUSE");
        }
        if (n==3)
        {
            system("CLS");
//Ingresar nuevo jugador o editar uno registrado.
            char pregunta;
            int idequipo = 0;
            int idjugador=0;
            if (cuantos_equipos_cargados_hay(orden)==0)
            {
                printf("\nAun no hay Equipos cargados\n");
                system("PAUSE");
            }
            else
            {
                printf("\nIngrese Id del Equipo, para agregar o modificar jugadores???");
                scanf("%d",&idequipo);
                printf("\nEl equipo %s consta de %d jugadores registrados!!\n", orden[idequipo-1].nombre, cuantos_jugadores_cargados_hay(orden, idequipo-1));
                printf("\n");
                system("PAUSE");
                idjugador=cuantos_jugadores_cargados_hay(orden, idequipo-1);
                if (idjugador <= jugadores_cant)
                {
                    printf("\nIngrese el Id del jugador a editar o crear, sera: %d, espacio disponible en la base.\n", idjugador+1);
                }
                else
                {
                    printf("\nLa base de datos esta llena, ha llegado a su limite de %d registros.\n", jugadores_cant);
                }
                printf ("\n\nDesea Aceptar este ID o ingresar usted uno disponible entre 1 y %d, ? s/n:\n", jugadores_cant);
                fflush(stdin);
                scanf ("%c",&pregunta);
                if (toupper(pregunta)=='s')
                {
                    fflush(stdin);
                    scanf ("%d",&idjugador);
                }
                printf("\n");
                cargar_jugadores_manual(orden, idequipo-1, idjugador-1);
                printf("\n");
                system("PAUSE");
            }
        }
        if (n==4)
        {
            system("CLS");
//Mostramos los equipos solamente
            mostrar_equipos_y_jugadores(orden, Imprimiendo.Por_equipos_solamente);
            printf("\n"); //Mostramos los equipos y sus jugadores
            int idequipo = 0;
            if (cuantos_equipos_cargados_hay(orden)==0)
            {
                printf("\nAun no hay jugadores cargados\n");
                system("PAUSE");
            }
            else
            {
                printf("\n");
                /*printf("\nIngrese Id del Equipo, para averiguar cuantos jugadores han sido cargados???");
                scanf("%d",&idequipo);
                printf("\nEl equipo %s consta de %d jugadores registrados!!\n", orden[idequipo-1].nombre, cuantos_jugadores_cargados_hay(orden, idequipo-1));
                printf("\n");
                system("PAUSE");*/
            }
            system("PAUSE");
        }
        if (n==5)
        {
            system("CLS");
//Mostramos los equipos y sus jugadores
            mostrar_equipos_y_jugadores(orden, Imprimiendo.Por_equipos_y_jugadores);
            printf("\n");
            system("PAUSE");
        }
        if (n==6)
        {
            system("CLS");
//Mostramos los equipos y sus jugadores y goles
            mostrar_equipos_y_jugadores(orden, Imprimiendo.Por_equipos_y_jugadores_goles);
            printf("\n");
            system("PAUSE");
        }
        if (n==7)
        {
            system("CLS");
//Mostramos los equipos y sus jugadores y sanciones
            mostrar_equipos_y_jugadores(orden, Imprimiendo.Por_equipos_y_jugadores_sanciones);
            printf("\n");
            system("PAUSE");
        }
        if (n==8)
        {
            system("CLS");
//Mostramos los equipos cuantos hay registrados
            printf("\nLa base de datos consta de %d equipos registrados!!\n", cuantos_equipos_cargados_hay(orden));
            printf("\n");
            system("PAUSE");
        }
        if (n==9)
        {
            system("CLS");
//Mostramos los jugadores de un equipo y cuantos hay registrados.
            int idequipo = 0;
            if (cuantos_equipos_cargados_hay(orden)==0)
            {
                printf("\nAun no hay Equipos cargados\n");
                system("PAUSE");
            }
            else
            {
                printf("\nIngrese Id del Equipo, para averiguar cuantos jugadores han sido cargados???");
                scanf("%d",&idequipo);
                printf("\nEl equipo %s consta de %d jugadores registrados!!\n", orden[idequipo-1].nombre, cuantos_jugadores_cargados_hay(orden, idequipo-1));
                printf("\n");
                system("PAUSE");
            }
        }
        if (n==10)
        {
            system("CLS");
//Ordenamos la base de datos por Nombre de Equipo
            ordenar_de_menor_a_mayor(orden, equipos_cant, Ordenando.por_equipo);
            printf("\nBase de datos, ordenada correctamente por Nombre de Equipo\n");
            system("PAUSE");
        }
        if (n==11)
        {
            system("CLS");
//Ordenamos la base de datos por Nombre de Equipo
            ordenar_de_menor_a_mayor(orden, equipos_cant, Ordenando.por_puntos_por_equipo);
            printf("\nBase de datos, ordenada correctamente por puntos por Equipo\n");
            system("PAUSE");
        }
        if (n==12)
        {
            system("CLS");
//Ordenamos la base de datos por Nombre de Jugador
            ordenar_de_menor_a_mayor(orden, equipos_cant, Ordenando.por_jugador);
            printf("\nBase de datos, ordenada correctamente por jugadores\n");
            system("PAUSE");
        }
        if (n==13)
        {
            system("CLS");
//Ordenamos la base de datos por edad del Jugador
            ordenar_de_menor_a_mayor(orden, equipos_cant, Ordenando.por_edad);
            printf("\nBase de datos, ordenada correctamente por edad de jugadores\n");
            system("PAUSE");
        }
        if (n==14)
        {
            system("CLS");
//Ordenamos la base de datos por Goles del Jugador.
            ordenar_de_menor_a_mayor(orden, equipos_cant, Ordenando.por_goles);
            printf("\nBase de datos, ordenada correctamente por goles de jugadores\n");
            system("PAUSE");
        }
        if (n==15)
        {
            system("CLS");
//Grabamos a disco la estructura
            guardar_estructura(orden);
            printf("\nBase de datos grabada correctamente!!.\n");
            system("PAUSE");
        }
        if (n==16)
        {
            system("CLS");
//Grabamos a disco la estructura
            leer_estructura(orden);
            printf("\nBase de datos cargada correctamente!!.\n");
            system("PAUSE");
        }
    }
    while(n!=17);

    printf("\n");
    system("PAUSE");
}

//------------------------------------------------
//Funcion para cargar automaticamente equipos y jugadores de cada uno
//En este caso dos equipos y dos jugadores por cada uno
//------------------------------------------------
void cargar_equipos_y_jugadores(struct equipo orden[])
{
//Equipo 1
    strcpy(orden[0].nombre, "Sportivo Bragado");
    strcpy(orden[0].barrio, "San Luis");
    orden[0].puntos = 20;
//Jugador 1
    strcpy(orden[0].team[0].nombre, "Luis Pedro");
    orden[0].team[0].edad = 20;
    orden[0].team[0].dni = 11230700;
    orden[0].team[0].goles = 3;
    orden[0].team[0].amarillas = 2;
    orden[0].team[0].rojas = 1;
//Jugador 2
    strcpy(orden[0].team[1].nombre, "Jorge Alberto");
    orden[0].team[1].edad = 30;
    orden[0].team[1].dni = 10200000;
    orden[0].team[1].goles = 13;
    orden[0].team[1].amarillas = 12;
    orden[0].team[1].rojas = 3;
//Equipo 2
    strcpy(orden[1].nombre, "Bragado Club");
    strcpy(orden[1].barrio, "San Pedro");
    orden[1].puntos = 15;
//Jugador 1
    strcpy(orden[1].team[0].nombre, "Hernan Oscar");
    orden[1].team[0].edad = 18;
    orden[1].team[0].dni = 21220202;
    orden[1].team[0].goles = 10;
    orden[1].team[0].amarillas = 6;
    orden[1].team[0].rojas = 5;
//Jugador 2
    strcpy(orden[1].team[1].nombre, "Anibal Hugo");
    orden[1].team[1].edad = 25;
    orden[1].team[1].dni = 101010101;
    orden[1].team[1].goles = 3;
    orden[1].team[1].amarillas = 1;
    orden[1].team[1].rojas = 0;
    printf("\nSe han cargado automaticamente dos equipos con dos jugadores cada uno.");
}
//------------------------------------------------
//Funcion para mostrar equipos y jugadores de cada uno
//------------------------------------------------
void mostrar_equipos_y_jugadores(struct equipo orden[], int opciones)
{
//De acuerdo a las opciones mostramos los equipos y sus jugadores
    int equipos=0;
    int jugadores=0;
    int cuenta_equipos=0;
    int cuenta_jugadores=0;
    switch (opciones)
    {
    case 1:
        printf("\nEQUIPOS: ");
        printf("\n---------------------");
        for(equipos = 0; equipos < equipos_cant; equipos++)
        {
            if (orden[equipos].nombre[0] != NULL)
            {
                cuenta_equipos++;
                printf("\n---------------------");
                printf("\nEquipo:%d\t%s",equipos+1,orden[equipos].nombre);
                printf("\nBarrio: \t%s",orden[equipos].barrio);
                printf("\nPuntos: \t%i",orden[equipos].puntos);
                printf("\n---------------------");
            }
        }
        if (cuenta_equipos == 0)
        {
            printf("\nAun no hay equipos cargados");
        }
        else
        {
            printf("\nSe han cargado:%d\ equipos.",cuenta_equipos);
        }
        break;
    case 2:
        printf("\nEQUIPOS: ");
        printf("\n---------------------");
        for(equipos = 0; equipos < equipos_cant; equipos++)
        {
            if (orden[equipos].nombre[0] != NULL )
            {
                cuenta_equipos++;
                printf("\n---------------------");
                printf("\nEquipo:%d\t%s",equipos+1,orden[equipos].nombre);
                printf("\nBarrio: \t%s",orden[equipos].barrio);
                printf("\nPuntos: \t%i",orden[equipos].puntos);
                printf("\n---------------------");
                printf("\nJUGADORES");
                printf("\n---------------------");
                for(jugadores = 0; jugadores < jugadores_cant; jugadores++)
                {
                    if (orden[equipos].team[jugadores].nombre[0] != NULL )
                    {
                        cuenta_jugadores++;
                        printf("\n\tJugador n:%d\t%s",jugadores+1,orden[equipos].team[jugadores].nombre);
                        printf("\n\tEdad: \t%i",orden[equipos].team[jugadores].edad);
                        printf("\n\tDni: \t%i",orden[equipos].team[jugadores].dni);
                        printf("\n\tGoles: \t%i",orden[equipos].team[jugadores].goles);
                        printf("\n\tAmarillas: \t%i",orden[equipos].team[jugadores].amarillas);
                        printf("\n\tRojas: \t%i",orden[equipos].team[jugadores].rojas);
                        printf("\n\t---------------------");
                    }
                }
                if (cuenta_jugadores == 0)
                {
                    printf("\nAun no hay jugadores cargados");
                }
                else
                {
                    printf("\nSe han cargado:%d\ jugadores.",cuenta_jugadores);
                    cuenta_jugadores=0;
                }
            }
        }
        if (cuenta_equipos == 0)
        {
            printf("\nAun no hay equipos cargados");
        }
        else
        {
            printf("\nSe han cargado:%d\ equipos.",cuenta_equipos);
        }
        break;
    case 3:
        printf("\nEQUIPOS: ");
        printf("\n---------------------");
        for(equipos = 0; equipos < equipos_cant; equipos++)
        {
            if (orden[equipos].nombre[0] != NULL )
            {
                cuenta_equipos++;
                printf("\n---------------------");
                printf("\nEquipo:%d\t%s",equipos+1,orden[equipos].nombre);
                printf("\nBarrio: \t%s",orden[equipos].barrio);
                printf("\nPuntos: \t%i",orden[equipos].puntos);
                printf("\n---------------------");
                printf("\nJUGADORES");
                printf("\n---------------------");
                for(jugadores = 0; jugadores < jugadores_cant; jugadores++)
                {
                    if (orden[equipos].team[jugadores].nombre[0] != NULL )
                    {
                        cuenta_jugadores++;
                        printf("\n\tJugador n:%d\t%s",jugadores+1,orden[equipos].team[jugadores].nombre);
                        printf("\n\tGoles: \t%i",orden[equipos].team[jugadores].goles);
                        printf("\n\t---------------------");
                    }
                }
                if (cuenta_jugadores == 0)
                {
                    printf("\nAun no hay jugadores cargados");
                }
                else
                {
                    printf("\nSe han cargado:%d\ jugadores.",cuenta_jugadores);
                    cuenta_jugadores=0;
                }
            }
        }
        if (cuenta_equipos == 0)
        {
            printf("\nAun no hay equipos cargados");
        }
        else
        {
            printf("\nSe han cargado:%d\ equipos.",cuenta_equipos);
        }
        break;
    case 4:
        printf("\nEQUIPOS: ");
        printf("\n---------------------");
        for(equipos = 0; equipos < equipos_cant; equipos++)
        {
            if (orden[equipos].nombre[0] != NULL )
            {
                cuenta_equipos++;
                printf("\n---------------------");
                printf("\nEquipo:%d\t%s",equipos+1,orden[equipos].nombre);
                printf("\nBarrio: \t%s",orden[equipos].barrio);
                printf("\nPuntos: \t%i",orden[equipos].puntos);
                printf("\n---------------------");
                printf("\nJUGADORES");
                printf("\n---------------------");
                for(jugadores = 0; jugadores < jugadores_cant; jugadores++)
                {
                    if (orden[equipos].team[jugadores].nombre[0] != NULL )
                    {
                        cuenta_jugadores++;
                        printf("\n\tJugador n:%d\t%s",jugadores+1,orden[equipos].team[jugadores].nombre);
                        printf("\n\tAmarillas: \t%i",orden[equipos].team[jugadores].amarillas);
                        printf("\n\tRojas: \t%i",orden[equipos].team[jugadores].rojas);
                        printf("\n\t---------------------");
                    }
                }
                if (cuenta_jugadores == 0)
                {
                    printf("\nAun no hay jugadores cargados");
                }
                else
                {
                    printf("\nSe han cargado:%d\ jugadores.",cuenta_jugadores);
                    cuenta_jugadores=0;
                }
            }
        }
        if (cuenta_equipos == 0)
        {
            printf("\nAun no hay equipos cargados");
        }
        else
        {
            printf("\nSe han cargado:%d\ equipos.",cuenta_equipos);
        }
        break;
    }
}
//------------------------------------------------
//Funcion para determinar cantidad de equipos cargados, su ubicacion y posicones libres
//------------------------------------------------
int cuantos_equipos_cargados_hay(struct equipo orden[])
{
    int equipos=0;
    int cuenta =0;
    for(equipos = 0; equipos < equipos_cant; equipos++)
    {
        if (orden[equipos].nombre[0] != NULL)
        {
            cuenta++;
            printf("\nEquipo:%d\t%s",equipos+1,orden[equipos].nombre);
        }
    }
    return cuenta;
}
//------------------------------------------------
//Funcion para determinar cantidad de equipos cargados, su ubicacion y posicones libres
//------------------------------------------------
int cuantos_jugadores_cargados_hay(struct equipo orden[], int idequipo)
{
    int jugadores=0;
    int cuenta =0;
    printf("Id equipo %i",idequipo);
    for(jugadores = 0; jugadores < jugadores_cant; jugadores++)
    {
        if (orden[idequipo].team[jugadores].nombre[0] != NULL)
        {
            cuenta++;
            printf("\n\tJugador n:%d\t%s",jugadores+1,orden[idequipo].team[jugadores].nombre);
        }
    }
    return cuenta;
}
//------------------------------------------------
//Funcion para cargar manualmente equipos
//------------------------------------------------
void cargar_equipos_manual(struct equipo orden[], int indice)
{
    system("CLS");
    fflush(stdin);
    printf ("\nIngrese Nombre: \n");
    gets (orden[indice].nombre);
    fflush(stdin);
    printf ("\nIngrese puntos: \n");
    scanf ("%d",&orden[indice].puntos);
    fflush(stdin);
    printf ("\nIngresar Barrio: \n");
    gets (orden[indice].barrio);
}
//------------------------------------------------
//Funcion para cargar manualmente jugadores
//------------------------------------------------
void cargar_jugadores_manual(struct equipo orden[], int indice_equipo, int indice_jugador)
{
    system("CLS");
    fflush(stdin);
    printf("\nIngresar Nombre de1 Jugador nº %d: \t",indice_jugador+1);
    gets (orden[indice_equipo].team[indice_jugador].nombre);
    fflush(stdin);
    printf ("\nIngresar Edad: \t");
    scanf ("%d",&orden[indice_equipo].team[indice_jugador].edad);
    fflush(stdin);
    printf ("\n Ingresar Dni: \t");
    scanf ("%d",&orden[indice_equipo].team[indice_jugador].dni);
    fflush(stdin);
    printf ("\nCantidad de Goles: \t");
    scanf ("%d",&orden[indice_equipo].team[indice_jugador].goles);
    fflush(stdin);
    printf ("\nCantidad de Targetas amarillas: \t");
    scanf ("%d",&orden[indice_equipo].team[indice_jugador].amarillas);
    fflush(stdin);
    printf ("\nCantidad de Targetas Rojas: \t");
    scanf ("%d",&orden[indice_equipo].team[indice_jugador].rojas);
    fflush(stdin);
}
//------------------------------------------------
//Funcion para cargar manualmente jugadores
//------------------------------------------------
/*Funcion para ordenar
recibe como parametro la estructura, la cantidad de elementos
y el tipo de orden que se desea realizar*/
void ordenar_de_menor_a_mayor(struct equipo orden[], int elementos, int opcion)
{
    int i, j, x, y;
    struct equipo aux[equipos_cant];
    struct equipo auxuno[equipos_cant];
    for (i=0; i<elementos-1; i++)
    {
        for (j=i+1; j<elementos; j++)
        {
//Por nombre de equipo
            if (opcion == 1)
            {
                if(stricmp( orden[i].nombre, orden[j].nombre)>0)
                {
                    aux[i] = orden[i]; /* guardamos el valor [i] */
                    orden[i] = orden[j]; /* le asignamos [j] a [i] */
                    orden[j] = aux[i]; /* le asignamos "aux" a [j] */
                }
            }
//Por puntos por equipo
            if (opcion == 2)
            {
                if(orden[i].puntos > orden[j].puntos)
                {
                    aux[i] = orden[i];
                    orden[i] = orden[j];
                    orden[j] = aux[i];
                }
            }
//Por nombre de jugador
            if (opcion == 3)
            {
                for (x=0; x<11-1; x++)
                {
                    for (y=x+1; y<11; y++)
                    {
                        if(stricmp( orden[i].team[x].nombre, orden[i].team[y].nombre)>0)
                        {
                            auxuno[i].team[x] = orden[i].team[x]; /* guardamos el valor [i] */
                            orden[i].team[x] = orden[i].team[y]; /* le asignamos [j] a [i] */
                            orden[i].team[y] = auxuno[i].team[x]; /* le asignamos "auxuno" a [j] */
                        }
                    }
                }
            }
//Por edad de jugador
            if (opcion == 4)
            {
                for (x=0; x<11-1; x++)
                {
                    for (y=x+1; y<11; y++)
                    {
                        if(orden[i].team[x].edad > orden[i].team[y].edad)
                        {
                            auxuno[i].team[x] = orden[i].team[x]; /* guardamos el valor [i] */
                            orden[i].team[x] = orden[i].team[y]; /* le asignamos [j] a [i] */
                            orden[i].team[y] = auxuno[i].team[x]; /* le asignamos "auxuno" a [j] */
                        }
                    }
                }
            }
//Por Goles de jugador
            if (opcion == 5)
            {
                for (x=0; x<11-1; x++)
                {
                    for (y=x+1; y<11; y++)
                    {
                        if(orden[i].team[x].goles > orden[i].team[y].goles)
                        {
                            auxuno[i].team[x] = orden[i].team[x]; /* guardamos el valor [i] */
                            orden[i].team[x] = orden[i].team[y]; /* le asignamos [j] a [i] */
                            orden[i].team[y] = auxuno[i].team[x]; /* le asignamos "auxuno" a [j] */
                        }
                    }
                }
            }
        }
    }
}
//------------------------------------------------
//Funcion para grabar a disco la estructura
//------------------------------------------------
void guardar_estructura(struct equipo orden[])
{
    FILE* archivo=fopen("c:\\equipos.dat","wb");
    fwrite(orden, sizeof(struct equipo), 5, archivo);
    fclose(archivo);
}
//------------------------------------------------
//Funcion para cargar manualmente jugadores
//------------------------------------------------
void leer_estructura(struct equipo orden[])
{
    FILE* archivo=fopen("c:\\equipos.dat","rb");
    fread(orden, sizeof(struct equipo), 5, archivo);
    fclose(archivo);
}

:arrow: --------------------------------------------------------------------------

No hay comentarios:

Publicar un comentario en la entrada

Dejanos la consulta sobre tu código, y con gusto a la mayor brevedad posible te responderemos...

Elinv.