TP5

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

//*Soit la structure de données suivante
typedef struct list
{
    int number;
    struct list *next;

} listElement, *List;

//*Protopypes
List new_list(void);
bool is_empty_list(List li);
int length_list(List li);
int sum_list(List li);
void print_list(List li);
List push_back_list(List li, int number);
List push_front_list(List li, int number);
List pop_back_list(List li);
List pop_front_list(List li);
void free_list(List li);
List reverse_list(List li);
List sort_list(List li);
List insert_in_sorted_list(List li, int number);
int **create_mat(int c, int l);
void get_values_mat(int **mat, int c, int l);
void print_mat(int **mat, int c, int l);
List *mat_to_listArr(int **mat, int c, int l);
List *delete_column_array(List *tab, int *c, int col);
void print_tab(List *tab, int c, int l);
List *multiply(List *tab1, int c1, int l1, List *tab2, int c2, int l2, int *c3, int *l3);
bool is_able_multiply(int c, int l);
int get_number(List li, int number);

int main(void)
{
    List liste = new_list();
    int insert;

    liste = push_back_list(liste, 23);
    liste = push_back_list(liste, 11);
    liste = push_back_list(liste, 2);
    liste = push_back_list(liste, 4);

    print_list(liste);

    printf("la somme des elements de la liste : %d\n", sum_list(liste));

    printf("\n  -> inversement d'ordre de la liste ...\n\n");
    liste = reverse_list(liste);
    print_list(liste);
    printf("\n  -> trie de la liste ...\n");
    liste = sort_list(liste);
    print_list(liste);
    printf("\nveillez entrer un nombre a inserer dans la liste triee : ");
    scanf("%d", &insert);
    printf("\n  -> insertion de la valeur %d dans la liste triee ...\n\n", insert);
    liste = insert_in_sorted_list(liste, insert);
    print_list(liste);

    free_list(liste);
    printf("\n---------------------------------------------------------------\n");

    int c1, l1, c2, l2, cas;

    /*--------------------------------------------------------------------*/

    printf("veillez entrer le taille de la premiere matrice (LxC): ");
    scanf("%dx%d", &l1, &c1);

    int **mat1 = create_mat(c1, l1);

    printf("veillez entrer les valeurs de la premiere matrice :\n");
    get_values_mat(mat1, c1, l1);

    /*--------------------------------------------------------------------*/

    printf("veillez entrer le taille de la deuxieme matrice (LxC): ");
    scanf("%dx%d", &l2, &c2);

    int **mat2 = create_mat(c2, l2);

    printf("veillez entrer les valeurs de la deuxieme matrice :\n");
    get_values_mat(mat2, c2, l2);

    /*--------------------------------------------------------------------*/

    printf("\n  -> transformation des deux matrices en tableaux de listes chainees ...\n\n");
    List *tab1 = mat_to_listArr(mat1, c1, l1);
    List *tab2 = mat_to_listArr(mat2, c2, l2);

    do
    {
        printf("veillez entrer la colonne a supprimer des deux tableaux (0 pour passer) : ");
        scanf("%d", &cas);
        if (cas == 0)
            break;
    } while (cas > c1 || cas > c2);

    if (cas != 0)
    {
        printf("\n  -> supression des colonnes ...");
        tab1 = delete_column_array(tab1, &c1, cas);
        tab2 = delete_column_array(tab2, &c2, cas);
    }

    printf("\n  -> realisation du produit matriciel ...\n\n");

    int c3, l3;
    List *tab3 = multiply(tab1, c1, l1, tab2, c2, l2, &c3, &l3);

    print_tab(tab3, c3, l3);

    free(tab1);
    free(tab2);
    free(mat1);
    free(mat2);
    free(tab3);
    return 0;
}

List new_list(void)
{
    return NULL;
}

bool is_empty_list(List li)
{
    if (li == NULL)
        return true;
    return false;
}

int length_list(List li)
{
    int cpt = 0;

    if (!is_empty_list(li))
    {
        listElement *tmp = li;
        while (tmp != NULL)
        {
            cpt++;
            tmp = tmp->next;
        }
    }

    return cpt;
}

void print_list(List li)
{
    printf("les elements de la liste:\n");
    if (is_empty_list(li))
    {
        printf("\tRien a afficher, la liste est vide.\n\n");
        return;
    }
    listElement *tmp = li;

    while (tmp != NULL)
    {
        printf("  [%02d]\n", tmp->number);
        tmp = tmp->next;
    }
}

int sum_list(List li)
{
    int cpt = 0;

    if (!is_empty_list(li))
    {
        listElement *tmp = li;

        while (tmp != NULL)
        {
            cpt += tmp->number;
            tmp = tmp->next;
        }
    }

    return cpt;
}

List push_back_list(List li, int number)
{
    listElement *element;

    element = malloc(sizeof(*element));
    if (element == NULL)
    {
        fprintf(stderr, "erreur d'allocation dynamique.\n");
        exit(EXIT_FAILURE);
    }

    element->number = number;
    element->next = NULL;

    if (is_empty_list(li))
        return element;

    listElement *tmp;

    tmp = li;

    while (tmp->next != NULL)
        tmp = tmp->next;

    tmp->next = element;

    return li;
}

List push_front_list(List li, int number)
{
    listElement *element;

    element = malloc(sizeof(*element));
    if (element == NULL)
    {
        fprintf(stderr, "erreur d'allocation dynamique.\n");
        exit(EXIT_FAILURE);
    }

    element->number = number;
    element->next = li;

    return element;
}

List pop_back_list(List li)
{
    if (is_empty_list(li))
        return new_list();

    if (li->next == NULL)
    {
        free(li);
        return new_list();
    }

    listElement *tmp = li, *previous;

    while (tmp->next != NULL)
    {
        previous = tmp;
        tmp = tmp->next;
    }
    previous->next = NULL;
    free(tmp);
    tmp = NULL;

    return li;
}

List pop_front_list(List li)
{
    if (is_empty_list(li))
        return new_list();

    if (li->next == NULL)
    {
        free(li);
        return new_list();
    }

    listElement *tmp = li->next;
    free(li);
    return tmp;
}

void free_list(List li)
{
    if (is_empty_list(li))
    {
        free(li);
        return;
    }

    while (li != NULL)
        li = pop_front_list(li);
    free(li);
    return;
}

List reverse_list(List li)
{
    if (is_empty_list(li))
        return NULL;

    listElement *element;

    element = malloc(sizeof(*element));
    if (element == NULL)
    {
        fprintf(stderr, "erreur d'allocation dynamique.\n");
        exit(EXIT_FAILURE);
    }

    element->number = li->number;
    element->next = NULL;

    li = li->next;

    while (li != NULL)
    {
        element = push_front_list(element, li->number);
        li = li->next;
    }
    return element;
}

List sort_list(List li)
{
    if (is_empty_list(li))
        return li;

    listElement *tmp = li, *element;
    int swap;

    element = tmp->next;
    while (tmp->next != NULL)
    {
        while (element != NULL)
        {
            if (tmp->number > element->number)
            {
                swap = tmp->number;
                tmp->number = element->number;
                element->number = swap;
            }
            element = element->next;
        }
        tmp = tmp->next;
        element = tmp->next;
    }
    return li;
}

List insert_in_sorted_list(List li, int number)
{
    listElement *element;

    element = malloc(sizeof(*element));

    if (element == NULL)
    {
        fprintf(stderr, "erreur d'allocation dynamique.\n");
        exit(EXIT_FAILURE);
    }

    element->number = number;
    element->next = NULL;

    if (is_empty_list(li))
    {
        return element;
    }

    listElement *tmp = li, *previous;

    while (tmp->number < number && tmp->next != NULL)
    {
        previous = tmp;
        tmp = tmp->next;
    }

    if (tmp->next == NULL && tmp->number < number)
        tmp->next = element;

    else
    {
        element->next = tmp;
        previous->next = element;
    }

    return li;
}

int **create_mat(int c, int l)
{
    int **mat;

    mat = malloc(sizeof(*mat) * c);

    for (int i = 0; i < c; i++)
        mat[i] = (int *)malloc(sizeof(int) * l);

    if (mat == NULL)
    {
        fprintf(stderr, "erreur d'allocation dynamyque.\n");
        exit(EXIT_FAILURE);
    }

    return mat;
}

void get_values_mat(int **mat, int c, int l)
{
    for (int i = 0; i < c; i++)
        for (int j = 0; j < l; j++)
        {
            printf("matrice[%d][%d] = ", j, i);
            scanf("%d", &mat[i][j]);
        }
}

void print_mat(int **mat, int c, int l)
{
    for (int i = 0; i < c; i++)
    {
        for (int j = 0; j < l; j++)
        {
            printf("[%02d] ", mat[i][j]);
        }
        printf("\n");
    }
}

List *mat_to_listArr(int **mat, int c, int l)
{
    List *arr;
    arr = malloc(sizeof(*arr) * c);
    if (arr == NULL)
    {
        fprintf(stderr, "erreur d'allocation dynamique.\n");
        exit(EXIT_FAILURE);
    }

    for (int i = 0; i < c; i++)
        for (int j = 0; j < l; j++)
            arr[i] = push_back_list(arr[i], mat[i][j]);

    return arr;
}

// delete_column_array(<tableau_de_listes>, <adresse_taille_tabeau>, <index_colonne_a_supprimer)
List *delete_column_array(List *tab, int *c, int col)
{
    if (col > *c || col == 0)
    {
        printf("impossible de supprimer la colonne '%d',\nla matrice ne contient que %d colonnes.\n", col, *c);
        return tab;
    }

    *c = *c - 1;

    for (int i = col - 1; i < *c; i++)
        tab[i] = tab[i + 1];

    return tab;
}

void print_tab(List *tab, int c, int l)
{
    for (int i = 0; i < l; i++)
    {
        for (int j = 0; j < c; j++)
            printf("[%d] ", get_number(tab[j], i));
        printf("\n");
    }
}

List *multiply(List *tab1, int c1, int l1, List *tab2, int c2, int l2, int *c3, int *l3)
{
    if (!is_able_multiply(c1, l2))
    {
        printf("impossible de multiplier les matrices.\n");
        return NULL;
    }

    *c3 = c2;
    *l3 = l1;

    int **mat = create_mat(*c3, *l3);

    int x, y;
    int somme;
    for (int i = 0; i < l1; i++)
        for (int j = 0; j < c2; j++)
        {
            somme = 0;
            for (int k = 0; k < c1; k++)
            {
                somme += get_number(tab1[k], i) * get_number(tab2[j], k);
            }
            mat[j][i] = somme;
        }

    return mat_to_listArr(mat, *c3, *l3);
}

bool is_able_multiply(int c, int l)
{
    if (c == l)
        return true;

    return false;
}

int get_number(List li, int number)
{
    if (number >= length_list(li))
    {
        return 0;
    }

    listElement *tmp = li;

    for (int i = 0; i < number; i++)
        tmp = tmp->next;
    return tmp->number;
}