Vous êtes sur la page 1sur 3

TP AI01 Alexandre Taesch

Maxime Six
Compte rendu TP AI01 : Listes chaînées.

• Void initialize(List *list)

Une liste créée dans main.c se place en entrée.


On met le head et tail à NULL.

Complexité: O(1). → Uniquement deux opérations élémentaires (affectation)

• Void insert_empty_list(List *list,char *str)

On a en entrée le pointeur vers la liste vide et un pointeur d’une chaine à insérer dans la liste vide.

On crée un pointeur qui correspondra à l’élément vide après le premier élément de la chaine (tmp).

On crée ensuite le premier élément constitué du ou des caractères de la chaine d’entrée. On crée d’abord le
premier élément (1 er caractère) puis si la chaine comporte plusieurs, on ajoute à la liste les autres caractères.

Enfin, un élément vide est mis en queue de la liste.

Complexité: O(1) : On crée un élément au début donc on ne parcours pas la liste.

data[0]=’\0’ pour indiquer un élément vide afin de séparer les nombres.

• Void insert_begining_list(List *list, char *str)

On a en entrée le pointeur vers la liste non vide et un pointeur d’une chaine à insérer dans la liste vide.

On crée une liste vide temporaire puis on insert grâce à insert_empty list l’élément voulu dedans.

Ensuite cet élément sera inséré au début de la liste passée en paramètre (non nulle).

Enfin la liste temporaire est supprimée.

Complexité: O(1). La fonction insert_empty_list coûte O(1) et le reste des opérations sont élémentaires.

• Void insert_end_list(List *list, char *str)

On a en entrée le pointeur vers la liste no vide et un pointeur d’une chaine à insérer dans la liste vide.

On crée une liste vide temporaire puis on insert grâce à insert_empty list l’élément voulu dedans.

Ensuite cet élément sera inséré à la fin de la liste passée en paramètre (non nulle).

Enfin la liste temporaire est supprimée.

Complexité: O(1). La fonction insert_empty_list coûte O(1) et nous n’avons que des opérations élémentaires.
TP AI01 Alexandre Taesch
Maxime Six
• int insert_after_position(List *list, char *str, int p)

On a en entrée le pointeur vers la liste non vide, un pointeur d’une chaine à insérer dans la liste vide et un entier
correspondant à la position de la liste à laquelle on veut insérer.

On va parcourir la liste pour trouver le P ème élément pour pouvoir insérer à cette position.

Une fois qu’on a trouver cette position dans la liste, on répète les opérations d’insertions.

Complexité: O(n). Dans le meilleur de cas, soit la liste est vide, soit on insère au début, on a O(1). Et dans le
pire de cas, on parcourt toute la liste, ce que nous donne O(n).

• int delete_data(List* list, int p)

On a en entrée le pointeur vers la liste non vide et un entier correspondant à la position de la liste à laquelle on
veut supprimer.

On va parcourir la liste pour trouver le P ème élément pour pouvoir supprimer à cette position.

Une fois qu’on a trouvé l’élément à supprimer, si il n’est pas au début ou en fin de
liste, on crée une liste intermédiaire en le remplissant avec les sous éléments de cet
éléments (chaque caractères) puis on supprime cette liste. Le nouvel élément
suivant à l’élement précédent l’élement supprimé est indiqué par posPrec-
>next=pos->next.

Complexité: O(n). Pour trouver la bonne position de donnée à détruit, on doit parcourir la liste de taille n.

• int compare(char *str1,char *str2)

On a en entrée le pointeur vers une première chaine de caractère et un autre pointeur vers une autre chaine de
caractère.

On utilise la fonction atoi pour convertir une chaîne de caractère en entier.

On va ensuite comparer simplement les deux chaines puis retournons 1 si str1>str2 et 2 sinon.

Complexité: O(1). On a un test simple et dans chaque cas une opération tient en compte.

• int sort(List *list);

Tant que la liste n’est pas vide


Le minimum = premier élément de la liste
On retrouve chaque nombre de la liste sous la forme d’un stringOn convertit ce
string en int
On apppelle compare avec le minimum et l’int qu’on vient de trouverSi notre nouveau
int est plus petit
alors il devient le minimum
Une fois la liste parcourue, le minimum est obtenu
on ajoute l’élément dans la Liste2 à la suite
TP AI01 Alexandre Taesch
Maxime Six
On enleve cet élément de la Liste1

A la fin on obtient une Liste2 trié, on fait pointer le head de Liste1 sur le head de Liste2 et le tail de Liste1 sur le
tail de Liste2

Complexité: O(n²). On cherche le min de la liste n fois.

• void display(List *list)

On a en entrée le pointeur vers la liste.


On parcourt la liste en utilisant pos qui désigne la position courante des
éléments puis on affiche l’élement courant en convertissant la chaine de
caractère en int.

Complexité: O(n). Il faut parcourir la liste de taille n.

• void destruct(List *list)

On a en entrée le pointeur vers la liste.


On parcourt la liste et supprime des éléments l’un après l’autre de structure Element. Ensuite on détruit la liste
tout entière.
Complexité: O(n). Il faut parcourir la liste de taille n.

Bonus

• void somme(List *list)


On parcourt chaque élément de la liste, on le convertit en int
On incrémente une variable somme de la valeur de cet élément
On ajoute à la fin de la liste (O(1)) comme on a un poiteur sur tail.

Complexité: O(n). Il faut parcourir la liste de taille n.

• Idées d’amélioration

Au niveau des possibilités d’amélioration, on peut imaginer la possibilité de faire une calculatrice avec ces
nombres et cette structure comportant tous les calculs élémentaires , mais aussi des calculs plus complexes.
On peut imaginer étendre ce projet avec des nombres floattant.

Vous aimerez peut-être aussi