Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Menu
Open sidebar
Benoit AUGER--DUBOIS
L2_S1_ALGO_STRUCT_DONNEE
Commits
bdeb69c2
Commit
bdeb69c2
authored
Dec 06, 2021
by
Benoit AUGER--DUBOIS
Browse files
jsp
parent
a6ca9472
Changes
1
Hide whitespace changes
Inline
Side-by-side
Tp5/tp5Bis.cpp
0 → 100644
View file @
bdeb69c2
#include <iostream>
#include <string>
using
namespace
std
;
/*
question 1.A : "salut"
question 1.B : "C'est un e liste chaîné e."
question 1.C : "un e autre liste "
*/
struct
t_cellule
{
char
info
;
t_cellule
*
suivant
;
};
// exercice 2:
/*------------------------------------------------------------
rôle : enregistrement en mémoire d’un message saisi par
l’utilisateur. La fin du message est marquée par un point. La
fonction retourne l’adresse de début du chainage */
t_cellule
*
enregistrement
(){
t_cellule
*
pcel
;
pcel
=
new
t_cellule
;
t_cellule
*
psuiv
;
t_cellule
*
tete
;
char
lettre
;
cout
<<
"une lettre ? (Un point pour terminer): "
<<
endl
;
cin
>>
lettre
;
//------------- debut de la liste
tete
=
pcel
;
while
(
lettre
!=
'.'
){
pcel
->
info
=
lettre
;
psuiv
=
new
t_cellule
;
pcel
->
suivant
=
psuiv
;
cout
<<
"une lettre ? (Un point pour terminer) "
<<
endl
;
cin
>>
lettre
;
pcel
=
psuiv
;
}
// ……………………… mémorisation du point final
pcel
->
info
=
lettre
;
pcel
->
suivant
=
nullptr
;
return
tete
;
}
/*-----------------------------------------------
rôle : affiche un message qui commence à l’adresse pdeb */
void
affiche
(
t_cellule
*
pdeb
){
char
lettre
;
t_cellule
*
pcel
;
pcel
=
pdeb
;
while
(
pcel
!=
nullptr
)
{
lettre
=
pcel
->
info
;
cout
<<
lettre
;
pcel
=
pcel
->
suivant
;
}
cout
<<
endl
;
}
/*----------------------------------------------
rôle : procédure récursive qui désalloue toutes les cases mémoires qui ont été allouées dynamiquement */
void
desaloue
(
t_cellule
*
pdeb
){
t_cellule
*
pcel
;
t_cellule
*
next
;
pcel
=
pdeb
;
if
(
pcel
!=
nullptr
){
next
=
pcel
->
suivant
;
delete
pcel
;
desaloue
(
next
);
}
}
/*----------------------------------------------
rôle : procédure qui crée un chaînage a partir d'une chaine de caractère*/
t_cellule
*
creationChainage
(
string
chaine
){
t_cellule
*
pcel
;
t_cellule
*
next
;
for
(
int
i
=
chaine
.
size
()
-
1
;
i
>
-
1
;
i
--
){
if
(
i
==
chaine
.
size
()
-
1
){
pcel
=
new
t_cellule
;
pcel
->
info
=
chaine
[
i
];
pcel
->
suivant
=
nullptr
;
next
=
pcel
;
}
else
{
pcel
=
new
t_cellule
;
pcel
->
info
=
chaine
[
i
];
pcel
->
suivant
=
next
;
next
=
pcel
;
}
}
return
pcel
;
}
//-----------------------------------------------
// programme principal
//
int
main
(){
/*
pour question 1 a 3 :
t_cellule* pcel;
pcel = enregistrement();
affiche(pcel);
desaloue(pcel);
*/
// pour question 4 :
t_cellule
*
pcel
;
string
ch
;
cout
<<
"entrer une chaine de caractère : "
;
getline
(
cin
,
ch
);
pcel
=
creationChainage
(
ch
);
affiche
(
pcel
);
desaloue
(
pcel
);
return
-
1
;
}
/* exercice 3 :
a) Réponse :
Il reste 6 cases mémoirs allouées dynamiquement ,
ces cases mémoirs ont été allouées dynamiquement lors de l'éxution de la fonction enregistrement(),
la fonction main() et la fonction affiche() n'alloue pas de case mémoirs dynamiquement.
démonstration :
main() ----------------------------------------------------------------------------------------------------
ligne | pcel | remarque/affichage
debut
1 @1 pcel <- enregistrement()
2 "salut."
fin
conclusion : le main n'alloue pas de case en mémoirs dynamiquement.
enregistrement() ------------------------------------------------------------------------------------------
ligne | lettre | pcel | psuiv | tete | @1 | @2 | affichage/remarque
debut
1 une lettre ? (un point pour terminer):
2 s
3 @1
4 @1
5 s != '.' vrai
6 info : s,suivant : ?
7 @2
8 info : s,suivant : @2
9 une lettre ? (un point pour terminer):
10 a
11 @2
12 s != '.' vrai
6 info : a,suivant : ?
7 @3
8 info : a,suivant : @3
9 une lettre ? (un point pour terminer):
10 l
11 @3
12 l != '.' vrai
conclusion : on s'arrête ici pour des raison de place, on se rend compte qu'il y a ( taille du mot(. non compris) + 1 ) allocation de mémoirs
lors de l'éxécution de la fonction enregistrement, en effet il y a une allocation au debut ligne 3,
puis une allocation par tour de boucle while ligne 7, or il y a n=taille du mot tour de boucle while.
Pour le mot "Salut." enregistrement va allouer 6 case mémoirs lors de son éxécution.
On ne test pas la procédure affiche car elle n'a pas d'allocation dynamique et c'est ce qui nous intérèsse ici.
b)
//----------------------------------------------
//rôle : procédure récursive qui désalloue toutes les cases mémoires qui ont été allouées dynamiquement
void desaloue(t_cellule* pdeb){
t_cellule* pcel;
t_cellule* next;
pcel = pdeb;
if (pcel != nullptr){
next = pcel->suivant;
delete pcel;
desaloue(next);
}
}
*/
// Question 5 :
struct
t_seance
{
int
numeroSemaine
;
int
jourSemaine
;
// 1=lundi, 2=mardi, ...
int
heures
;
// de 8 à 18
int
minutes
;
// 0 ou 30
t_seance
*
seanceSuivante
;
t_seance
*
seancePrecedent
;
};
/*rôle : desalloue la seance donnée en entrée sans briser le chainage
precondition : le t_seance* != nullptr en entrée */
void
desallocationSeance
(
t_seance
*
seance
){
if
(
seance
->
seanceSuivante
==
nullptr
){
seance
->
seancePrecedent
->
seanceSuivante
=
nullptr
;
delete
seance
;
}
if
(
seance
->
seancePrecedent
==
nullptr
){
seance
->
seanceSuivante
->
seancePrecedent
=
nullptr
;
delete
seance
;
}
(
seance
->
seancePrecedent
)
->
seanceSuivante
=
seance
->
seanceSuivante
;
(
seance
->
seanceSuivante
)
->
seancePrecedent
=
seance
->
seancePrecedent
;
delete
seance
;
}
//rôle : fonction qui retourne la première séance d'une liste chainé de séance */
t_seance
*
findFirstSeance
(
t_seance
*
seance
){
if
(
seance
->
seancePrecedent
==
nullptr
){
return
seance
;
}
return
findFirstSeance
(
seance
->
seancePrecedent
);
}
// Question 5.1 :
/*----------------------------------------------
rôle : Fonction qui retourne le nombre de séance après une séance dans une liste chainé de séance */
int
CountSeance
(
t_seance
*
seance
){
t_seance
*
temp
;
int
nbSeance
=
0
;
if
(
seance
==
nullptr
){
cout
<<
"Il n'y a pas de séance."
<<
endl
;
}
else
{
temp
=
seance
;
while
(
temp
!=
nullptr
){
nbSeance
++
;
temp
=
temp
->
seanceSuivante
;
}
}
return
nbSeance
;
}
// Question 5.2 :
/*----------------------------------------------
rôle : procédure affiche les dates de toutes les séances après une séance données et de la séance donnée */
void
affichageSeance
(
t_seance
*
seance
){
if
(
seance
!=
nullptr
){
// cette conditionelle est utile pour la première itération du programme uniquement
cout
<<
"Numero de semaine : "
<<
seance
->
numeroSemaine
<<
", jour : "
<<
seance
->
jourSemaine
<<
", heure : "
<<
seance
->
heures
<<
":"
<<
seance
->
minutes
<<
endl
;
}
else
{
cout
<<
"Il n'y a pas de séance."
<<
endl
;
}
if
(
seance
->
seanceSuivante
!=
nullptr
){
affichageSeance
(
seance
->
seanceSuivante
);
}
}
/*----------------------------------------------
rôle : procédure qui désalloue la séance donnée et les séance suivante a celle-ci */
// Question 5.3 :
void
desallocationSeanceSuiv
(
t_seance
*
seance
){
t_seance
*
temp
;
temp
=
seance
;
if
(
seance
!=
nullptr
){
temp
=
findFirstSeance
(
seance
);
while
(
temp
!=
nullptr
){
temp
=
temp
->
seanceSuivante
;
delete
temp
->
seancePrecedent
;
}
}
delete
temp
;
}
/*----------------------------------------------
rôle : procédure qui crée une séance puis l'ajoute après une séance donnée */
// Question 6.1 :
void
ajoutSeance
(
t_seance
*
seance
,
int
numeroSemaine
,
int
jourSemaine
,
int
heures
,
int
minutes
){
t_seance
*
ajout
=
new
t_seance
;
ajout
->
numeroSemaine
=
numeroSemaine
;
ajout
->
heures
=
heures
;
ajout
->
jourSemaine
=
jourSemaine
;
ajout
->
minutes
=
minutes
;
if
(
seance
->
seanceSuivante
==
nullptr
){
ajout
->
seancePrecedent
=
seance
;
ajout
->
seanceSuivante
=
nullptr
;
seance
->
seanceSuivante
=
ajout
;
}
else
{
ajout
->
seancePrecedent
=
seance
;
ajout
->
seanceSuivante
=
seance
->
seanceSuivante
;
seance
->
seanceSuivante
=
ajout
;
}
}
// Question 6.2 :
/*----------------------------------------------
rôle : procedure qui supprime la séance contenant les informations souhaité, si elle n'éxiste pas, on affiche les informations */
void
supprThisSeance
(
t_seance
*
seance
,
int
numeroSemaine
,
int
jourSemaine
,
int
heures
,
int
minutes
){
t_seance
*
tempSeance
=
findFirstSeance
(
seance
);
while
(
tempSeance
!=
nullptr
){
if
(
tempSeance
->
heures
!=
heures
||
tempSeance
->
jourSemaine
!=
jourSemaine
||
tempSeance
->
minutes
!=
minutes
||
tempSeance
->
numeroSemaine
||
numeroSemaine
){
tempSeance
=
tempSeance
->
seanceSuivante
;
}
else
{
desallocationSeance
(
tempSeance
);
break
;
}
}
if
(
tempSeance
==
nullptr
){
cout
<<
"Numero de semaine : "
<<
numeroSemaine
<<
", jour : "
<<
jourSemaine
<<
", heure : "
<<
heures
<<
":"
<<
minutes
<<
endl
;
}
}
// Question 6.3 :
/*----------------------------------------------
rôle : Fonction qui retourne le nombre de séance prévue après une séance (selon l'ordre chronologique) */
int
countSeanceChronologically
(
t_seance
*
seance
,
int
numeroSemaine
,
int
jourSemaine
,
int
heures
,
int
minutes
){
t_seance
*
temp
;
temp
=
seance
;
int
nbSeance
=
0
;
while
(
temp
!=
nullptr
){
if
(
temp
->
numeroSemaine
>=
seance
->
numeroSemaine
&&
temp
->
jourSemaine
>=
seance
->
jourSemaine
&&
temp
->
heures
>=
seance
->
heures
&&
temp
->
minutes
>=
seance
->
minutes
){
nbSeance
++
;
temp
=
temp
->
seanceSuivante
;
}
temp
=
temp
->
seanceSuivante
;
}
return
nbSeance
;
}
// Question 7.1 :
/*
Algo 6.1 : ne change pas que le chainage soit trié ou non.
Algo 6.2 : ne change pas que le chainage soit trié ou non.
Algo 6.3 : Si le chainage est trié il suffit de compter le nombre de séance après un élément donner,
cela ce fais de la même manière que l'algo CountSeance() fais a la question 5.1.
*/
// Question 7.2 :
/*
Maintenir le chainage trié permet de retrouver un élément de la chaine plus facilement, cela permet aussi de répertorier
la chaine facilement en catégorie et ainsi comparer ses éléments facilement.
*/
// Question 8 :
/*----------------------------------------------
rôle : fonction qui fusionne deux chaînages de séance en supprimant les doublons puis retourne le nouveaux chaînage. */
t_seance
*
fusionClone
(
t_seance
*
chaine1
,
t_seance
*
chaine2
){
chaine1
=
findFirstSeance
(
chaine1
);
chaine2
=
findFirstSeance
(
chaine2
);
t_seance
*
temp1
=
chaine1
;
t_seance
*
temp2
=
chaine2
;
while
(
temp2
!=
nullptr
){
while
(
temp1
!=
nullptr
){
if
(
temp1
->
numeroSemaine
==
temp2
->
numeroSemaine
&&
temp1
->
jourSemaine
==
temp2
->
jourSemaine
&&
temp1
->
heures
==
temp2
->
heures
&&
temp1
->
minutes
==
temp2
->
minutes
){
supprThisSeance
(
chaine1
,
temp1
->
numeroSemaine
,
temp1
->
jourSemaine
,
temp1
->
heures
,
temp1
->
minutes
);
}
temp1
=
temp1
->
seanceSuivante
;
}
temp2
=
temp2
->
seanceSuivante
;
temp1
=
chaine1
;
}
chaine1
->
seancePrecedent
=
return
chaine1
;
}
\ No newline at end of file
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment