Commit bdeb69c2 authored by Benoit AUGER--DUBOIS's avatar Benoit AUGER--DUBOIS
Browse files

jsp

parent a6ca9472
#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
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment