#include "partie1.c"



    /*PROTOTYPES*/
void listFilling (LSC*) ;
int part2_1_It (Maillon*) ;
int part2_1_Rec (Maillon*) ;
int part2_2_It (Maillon*, int) ;
int part2_2_Rec (Maillon*, int) ;
int part2_3_It (Maillon*, int) ;
int part2_3_Rec (Maillon*, int) ;
void part2_4_It (Maillon*) ;
void part2_4_Rec (Maillon*, int) ;
int part2_5_It (Maillon*) ;
int part2_5_Rec (Maillon*) ;



    /*MENU DE LA PARTIE 2*/
void part2()
{
    int resulScan, v, tmp ;
    short int choix ;
    char ItOrRec ;

    //Création de la liste :
    LSC *liste = malloc(sizeof(*liste)) ;
    liste->first = NULL ;

    //Saisie de la liste par l'utilisateur :
    listFilling (liste) ;

    do
    {
        //Nettoyage de la console :
        system ("CLS") ;

        //Choix de la question :
        printf("  1. Longueur d'une LSC\n  2. Position d'un element\n  3. Nombre d'occurences d'une valeur\n  4. Affichage d'un element sur deux\n  5. Verification de croissance\n  0. Quitter\n") ;
        resulScan = scanf ("%hi", &choix) ;
        fflush (stdin) ;
        while ( (resulScan != 1) || (choix < 0) || (choix > 5) )
        {
            printf ("\nERREUR : Entree incorrecte !\n") ;
            resulScan = scanf ("%hi", &choix) ;
            fflush (stdin) ;
        }

        if (choix != 0)
        {
            //Pour les cas 2 et 3, saisie de la valeur à rechercher :
            if ((choix == 2) || (choix == 3))
            {
                printf("Quel element souhaitez-vous rechercher ? ") ;
                resulScan = scanf ("%d", &v) ;
                fflush (stdin) ;
                while (resulScan != 1)
                {
                    printf ("\nERREUR : Entree incorrecte !\nQuel element souhaitez-vous rechercher ? ") ;
                    resulScan = scanf ("%d", &v) ;
                    fflush (stdin) ;
                }
            }

            //Choix du mode itératif ou récursif :
            printf ("\n\nIteratif (i) ou recursif (r) ? ") ;
            resulScan = scanf ("%c", &ItOrRec) ;
            fflush (stdin) ;
            while (resulScan != 1 || ((ItOrRec != 'i') && (ItOrRec != 'r')))
            {
                printf ("\nERREUR : Entree incorrecte !\nIteratif (i) ou recursif (r) ? ") ;
                resulScan = scanf ("%c", &ItOrRec) ;
                fflush (stdin) ;
            }

            //Affichage du résultat demandé :
            system("CLS") ;
            switch (choix)
            {
                case 1 :
                    //Affichage du nombre de maillons de la liste :
                    if (ItOrRec == 'i') { printf ("La LSC contient %d maillons.\n", part2_1_It (liste->first)) ; }
                    else { printf ("La LSC contient %d maillons.\n", part2_1_Rec (liste->first)) ; }
                    system ("PAUSE") ;
                    break ;
                case 2 :
                    //Recherche de l'élément "v" dans la liste :
                    if (ItOrRec == 'i') { tmp = part2_2_It (liste->first, v) ; }
                    else { tmp = part2_2_Rec (liste->first, v) ; }
                    //Affichage de l'emplacement s'il existe :
                    if (tmp == 0) { printf ("Cet element n'est pas present dans la liste.\n") ; }
                    else { printf ("Cet element se trouve dans le %de maillon.\n", tmp) ; }
                    system ("PAUSE") ;
                    break ;
                case 3 :
                    //Affichage du nombre d'occurences de l'élément "v" dans la liste :
                    if (ItOrRec == 'i') { printf ("Cet element est present %d fois dans la liste.\n", part2_3_It (liste->first, v)) ; }
                    else { printf ("Cet element est present %d fois dans la liste.\n", part2_3_Rec (liste->first, v)) ; }
                    system ("PAUSE") ;
                    break ;
                case 4 :
                    //Affichage d'un élément sur deux de la liste :
                    if (ItOrRec == 'i') { part2_4_It (liste->first) ; }
                    else { part2_4_Rec (liste->first, 1) ; }
                    system ("PAUSE") ;
                    break ;
                case 5 :
                    //Vérification de la croissance de la liste :
                    if (ItOrRec == 'i') { tmp = part2_5_It(liste->first) ; }
                    else { tmp = part2_5_Rec(liste->first) ; }
                    if (tmp) { printf ("Cette liste est strictement croissante.\n") ; }
                    else { printf ("Cette liste n'est pas strictement croissante.\n") ; }
                    system ("PAUSE") ;
                    break ;
                default :
                    break ;
            }
        }
    } while (choix != 0) ;
}



    /*LONGUEUR D'UNE LSC - ITERATIF*/
int part2_1_It (Maillon* current)
{
    int i = 0 ;

    if (current == NULL) { return 0 ; }
    while (current != NULL)
    {
        i++ ;
        current = current->suiv ;
    }
    return i ;
}



    /*LONGUEUR D'UNE LSC - RECURSIF*/
int part2_1_Rec (Maillon* current)
{
    if (current == NULL) { return 0 ; }
    return (1 + part2_1_Rec(current->suiv)) ;
}



    /*POSITION D'UN ELEMENT - ITERATIF*/
int part2_2_It (Maillon* current, int v)
{
    int i = 1 ;

    while ( (current != NULL) && (current->val != v) )
    {
        i++ ;
        current = current->suiv ;
    }
    if (current == NULL) { return 0 ; }
    else { return i ; }
}



    /*POSITION D'UN ELEMENT - RECURSIF*/
int part2_2_Rec (Maillon* current, int v)
{
    int position ;

    if (current == NULL) { return 0 ; }
    if (current->val == v) { return 1 ; }
    position = part2_2_Rec (current->suiv, v) ;
    if (position == 0) { return 0 ; }
    return (1 + position) ;
}



    /*NOMBRE D'OCCURENCES D'UNE VALEUR - ITERATIF*/
int part2_3_It (Maillon* current, int v)
{
    int nbOcc = 0 ;

    while (current != 0)
    {
        if (current->val == v) { nbOcc++ ; }
        current = current->suiv ;
    }
    return nbOcc ;
}



    /*NOMBRE D'OCCURENCES D'UNE VALEUR - RECURSIF*/
int part2_3_Rec (Maillon* current, int v)
{
    if (current == NULL) { return 0 ; }
    if (current->val == v) { return (1 + part2_3_Rec (current->suiv, v)) ; }
    return part2_3_Rec (current->suiv, v) ;
}



    /*AFFICHAGE D'UN ELEMENT SUR DEUX - ITERATIF*/
void part2_4_It (Maillon* current)
{
    int i = 0 ;

    while (current != NULL)
    {
        i++ ;
        if (i%2 != 0) { printf ("[%d] -> ", current->val) ; }
        current = current->suiv ;
    }
    printf ("END OF LIST\n") ;
}



    /*AFFICHAGE D'UN ELEMENT SUR DEUX - RECURSIF*/
void part2_4_Rec (Maillon* current, int indicator)
{
    if (current != NULL)
    {
        if (indicator >= 0) { printf ("[%d] -> ", current->val) ; }
        part2_4_Rec (current->suiv, (-1)*indicator) ;
    }
    else { printf ("END OF LIST\n") ; }
}



    /*VERIFICATION DE CROISSANCE - ITERATIF*/
int part2_5_It (Maillon* current)
{
    while ( (current != NULL) && (current->suiv != NULL) )
    {
        if (current->val >= current->suiv->val) { return 0 ; }
        current = current->suiv ;
    }
    return 1 ;
}



    /*VERIFICATION DE CROISSANCE - RECURSIF*/
int part2_5_Rec (Maillon* current)
{
    if ( (current != NULL) && (current->suiv != NULL) )
    {
        if (current->val >= current->suiv->val) { return 0 ; }
        else { return (part2_5_Rec (current->suiv)) ; }
    }
    else { return 1 ; }
}



    /*PERMET LA CREATION ET LA SAISIE D'UNE LSC DE N ELEMENTS*/
void listFilling (LSC *liste)
{
    char continueFilling ;
    int resulScan ;
    Maillon *previous = NULL, *current = malloc(sizeof(Maillon)) ;

    //Nettoyage de la console :
    system ("CLS") ;
    printf ("     [Saisie de la liste]\n\n\n") ;

    //Création du premier maillon :
    liste->first = current ;
    current->suiv = NULL ;
    printf ("Valeur du premier maillon ? ") ;
    resulScan = scanf ("%d", &current->val) ;
    fflush (stdin) ;
    while (resulScan != 1)
    {
        printf ("\nERREUR : Entree incorrecte !\nValeur du premier maillon ? ") ;
        resulScan = scanf ("%d", &current->val) ;
        fflush (stdin) ;
    }

    do
    {
        //Demande d'ajout d'un nouveau maillon :
        printf ("\n\nNouveau maillon ? (o/n) ") ;
        resulScan = scanf ("%c", &continueFilling) ;
        fflush (stdin) ;
        while ( (resulScan != 1) || ((continueFilling != 'o') && (continueFilling != 'n')) )
        {
            printf ("\nERREUR : Entree incorrecte !\nNouveau maillon ? (o/n) ") ;
            resulScan = scanf ("%c", &continueFilling) ;
            fflush (stdin) ;
        }

        //Ajout d'un nouveau maillon :
        if (continueFilling == 'o')
        {
            previous = current ;
            current = malloc(sizeof(Maillon)) ;
            previous->suiv = current ;
            current->suiv = NULL ;

            printf ("Valeur du maillon ? ") ;
            resulScan = scanf ("%d", &current->val) ;
            fflush (stdin) ;
            while (resulScan != 1)
            {
                printf ("\nERREUR : Entree incorrecte !\nValeur du maillon ? ") ;
                resulScan = scanf ("%d", &current->val) ;
                fflush (stdin) ;
            }
        }
    } while (continueFilling == 'o') ;
}