Media,Max,Min

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

typedef struct Lista{ //sintaxe do typedef: typedef [tipo de dados atual] [nome pelo qual se vai passar a chamar]

    int num;
    struct Lista *proximo, *anterior; //Ponteiros que apontam para um objecto do tipo struct Lista
                                    //(tal como int *p corresponde a um ponteiro que aponta para um objecto do tipo int)
}Lista;

//Funções que criam e inserem listas

Lista *criaLista(); //Esta função devolve um ponteiro (*) que aponta para um objeto do tipo struct Lista (Lista)

int insereNum(Lista *); //Esta função não devolve nada, mas recebe um ponteiro que aponta para um objecto do tipo struct Lista,
                        //neste caso, o primeiro elemento

//Função que mostra os numeros no ecrã

int mostraNum(Lista *);

//Funções que calculam média, mínimo e máximo

int avgLista(Lista *);

int minLista(Lista *);  //Recebem todas o cabeçalho (o primeiro elemento) da lista que se pretende efetuar as operações

int maxLista(Lista *);

int main(void){

    Lista *startLista = NULL; //Eu costumo inicializar todos os ponteiros com NULL, excepto em algumas situações.
                            //Neste caso também dá jeito, porque facilmente se verifica se a lista tem alguma coisa

    int esc;

    do{

        printf("\n\nOPCOES:\n\t1. Criar uma nova lista\n\t2. Inserir um numero\n\t3. Mostrar numeros introduzidos\n\t4. Media\n\t5. Minimo\n\t6. Maximo\n\t7. Sair\nIntroduza escolha: ");
        scanf("%d", &esc);
        fflush(stdin); //fflush(*FILE) força a limpeza do buffer de um stream (pode ser de um ficheiro,
                        //neste caso é o de entrada, stdin)

        switch(esc){

            case 1:
                if(startLista!=NULL){

                    printf("Ja existe uma lista."); //Como inicializei startLista a NULL, é fácil verificar se existe ou nao uma lista
                    break;
                }

                startLista = criaLista(); //Tens de guardar sempre o primeiro elemento da lista. startLista é um ponteiro
                                        //do mesmo tipo que criaLista() (Lista*), logo pode-se igualar, ficando startLista com o
                                        //endereço do ponteiro devolvido
                break;
            case 2:
                if(startLista==NULL){

                    printf("Nao existe uma lista."); //Verificação rápida se já existe o primeiro elemento
                    break;
                }

                insereNum(startLista); //insereNum recebe o cabeçalho da lista ao qual as outras estão ligadas
                break;
            case 3:
                mostraNum(startLista);  //Não é preciso verificar se startLista é NULL, porque se fôr, o ciclo for()
                                        //termina imediatamente e não apresenta nada no ecrã
                break;
            case 4:
                avgLista(startLista);
                break;
            case 5:
                minLista(startLista);
                break;
            case 6:
                maxLista(startLista);
                break;
        }
    }while(esc!=7);
}

Lista *criaLista(){ //Esta função devolve um ponteiro (*) que aponta para um objeto do tipo struct Lista (Lista)

    Lista *startLista = malloc(sizeof(Lista)); //Pede ao OS para reservar um bloco de memoria do tamanho do struct Lista (chamado Lista) e guarda o endereço desse bloco em startLista
                                                //startLista é um ponteiro para struct Lista, e para acedar aos dados desse struct é necessário usar "->"
                                                //startLista->num é a mesma coisa que (*startLista).num
                                                //Como startLista é um ponteiro, usando o * pode-se aceder ao objecto ao qual ele aponta, neste caso um struct. No entanto, "->" é muito mais fácil de perceber e usar

    if(startLista!=NULL){ //No caso extremamente raro onde o OS não pode reservar memória, ou seja, malloc() devolve NULL

        //Pede um numero ao utilizador e guarda-o no dado num do struct Lista, aqui apontado por startLista, logo guarda-o em startLista->num [ou (*startLista).num]
        printf("Introduza um numero: ");
        scanf("%d", &(startLista->num)); //startLista->num é um inteiro, logo o operador & tem de ser utilizado
        fflush(stdin);

        //Ponteiros dentro do struct

        //Como este é suposto ser o primeiro elemento, tanto como *anterior como *proximo apontam para NULL
        startLista->anterior = NULL;
        startLista->proximo = NULL;
    }
    else printf("Erro ao criar lista.");

    return startLista; //Devolve o cabeçalho a guardar em startLista. Lembra-te que a menos que declares uma variavel global,
                    //startLista do main() e este startLista são objectos diferentes, apesar de apontarem para a mesma coisa, e
                    //terem o mesmo nome
}

int insereNum(Lista *startLista){ //Esta função não devolve nada, mas recebe um ponteiro que aponta para um objecto do tipo struct
                                //Lista, neste caso, o primeiro elemento

    Lista *atualLista = NULL, *ultimaLista = NULL, *proximaLista = NULL, *novo = malloc(sizeof(Lista));

    //Este for() vai percorrer a lista do inicio ao fim e só para quando a lista atual for NULL. Como a condição
    //atualLista!=NULL só é testada depois da iteração acontecer, atualLista no final vai ser igual a NULL,
    //sendo necessãrio usar ultimaLista = atualLista
    for(atualLista = startLista; atualLista!=NULL; atualLista = atualLista->proximo){

        ultimaLista = atualLista;
    }

    //Mesma coisa que em criaLista(), pede um numero e guarda no struct, só que em vez de o ponteiro se chamar startLista,
    //chama-se novo, são ponteiros para as mesmas coisas
    printf("Introduza um numero: ");
    scanf("%d", &(novo->num)); //novo->num é um inteiro, logo o operador & tem de ser utilizado
    fflush(stdin);

    //Ponteiros dentro do struct

    //Para guardar o anterior, em vez de só fazeres ultimaLista->proximo = novo, fazes também o oposto,
    //logo novo->anterior = ultimaLista
    ultimaLista->proximo = novo;
    novo->anterior = ultimaLista;
    novo->proximo = NULL; //Coloca sempre o proximo a apontar para NULL
}
//Função que mostra os numeros no ecrã

int mostraNum(Lista *startLista){
     Lista *novo, *ponteiro_1, *ponteiro_2;
     novo = startLista;
   while(novo!=NULL){
     ponteiro_1 = novo->proximo;
     ponteiro_2 = novo->anterior;
     printf("O numero e %d \n", novo->num);
     novo=novo->proximo;
    }
}

//Funções que calculam média, mínimo e máximo

int avgLista(Lista *startLista){
    Lista *novo, *ponteiro_1, *ponteiro_2;
    novo = startLista;
    int valores = 0;
    int total = 0;
    int media;
    while(novo!=NULL){
        ponteiro_1 = novo->proximo;
        ponteiro_2 = novo->anterior;
        total += 1;
        valores = (novo->num) + valores;
        novo=novo->proximo;
    }
    media = valores/total;
    printf("A media e %d",media);
}


int minLista(Lista *startLista){ //Recebem todas o cabeçalho (o primeiro elemento) da lista que se pretende efetuar as operações
    Lista *novo, *ponteiro_1, *ponteiro_2;
    novo = startLista;
    int minimo,temp= (novo->num);
    while(novo!=NULL){
        ponteiro_1 = novo->proximo;
        ponteiro_2 = novo->anterior;
        minimo = (novo->num);
        if (minimo < temp){
            temp = minimo;
        }
        novo=novo->proximo;
    }
    printf("O valor minimo e %d",temp);
}

int maxLista(Lista *startLista){
    Lista *novo, *ponteiro_1, *ponteiro_2;
    novo = startLista;
    int minimo,temp= (novo->num);
    while(novo!=NULL){
        ponteiro_1 = novo->proximo;
        ponteiro_2 = novo->anterior;
        minimo = (novo->num);
        if (minimo > temp){
            temp = minimo;
        }
        novo=novo->proximo;
    }
    printf("O valor maximo e %d",temp);
}