Institut Rosario Castellanos

Structure de données

Expérience d'apprentissage:
Structures de données linéaires pour
dépannage : listes, piles et files d'attente

LAITI301B1O_21-2

Cadeaux
Fabián Antonio Osorio García

professeur
FRANCISCO JACOB AVILA CAMACHO

Mexico

septembre 2021

1
Expérience d'apprentissage : structures de données linéaires pour la
résolution de problèmes : listes, piles et files d'attente
But:

Incident critique

Revenons au contexte décrit par la problématique prototypique dans laquelle vous

êtes un jeune entrepreneur qui a proposé le développement d'une solution
informatique permettant aux personnes souhaitant se rendre au même endroit en
même temps de s'organiser pour voyager ensemble.

Dans un premier temps, nous devons définir et stocker les données de base dont
nous aurons besoin pour qu'un utilisateur puisse demander un voyage via notre
application « Ecoviaje ».

Ce que vous devez faire est de créer la structure de données (Demande) qui vous
permet de définir et de stocker les informations de base nécessaires à un
utilisateur pour demander un voyage.

Pour simplifier le problème, nous considérerons uniquement les attributs suivants :

• Origine : ville d'origine (par exemple Puebla).

• destination : ville de destination (par exemple CDMX).

• utilisateur : identifiant de l'utilisateur (par exemple, jperez)

Comment allez-vous faire cette demande ?

Les indications

Cette activité sera divisée en deux moments :

Premier instant

2
 1. Lisez attentivement le contenu de l'appareil.

2. Choisissez entre les alternatives d'implémentation d'une structure de

données de type liste, List Requests qui vous permet de stocker toutes les
requêtes basées sur une liste simple ou une double liste et expliquez
pourquoi vous avez choisi cette implémentation (justifiez-la)

3. Intégrez ces informations dans un document texte avec la nomenclature

suivante LAIT301_ U2_EA_nom paternel_prénom.

Il a été décidé d'utiliser des listes simples puisque seule une insertion ordonnée
par ordre d'entrée dans les listes A et B serait nécessaire. De cette façon, il n'est
pas nécessaire d'occuper une double liste puisque nous n'introduireions pas
d'éléments par derrière ni n'effectuerions de traversées d'éléments, l'insertion se
ferait d'un seul côté, comme s'il s'agissait d'une file d'attente.

Deuxième instant

4. Créez une classe ou une fonction pour gérer les demandes de déplacement
en véhicule partagé et une classe ou une fonction pour stocker toutes les
demandes. Listez les demandes en utilisant le langage de programmation et
le logiciel de votre choix (Si vous avez des doutes, consultez les
informations avec votre professeur)

La classe ou la fonction Vehicle Share doit implémenter/effectuer les méthodes ou

opérations suivantes :

a) fusionne les requêtes qui reçoivent en paramètres deux objets/données de type

Liste de requêtes.

La fonction ou la méthode doit renvoyer un objet de type Requests List dont le

contenu est constitué alternativement des éléments des deux listes d'entrée, c'est-
à-dire dans le même ordre, mais intégrant un élément de chaque liste.

3
Voyons un exemple avec des lettres :

Liste 1 : {A, C, D, E, F, G}

Liste 2 : {B, J}

Résultat des demandes de fusion : {A, B, C, J, D, E, F, G}

b) Share, qui reçoit en paramètres deux objets ou données de type Requests List,
et qui renvoie un objet de type Requests List avec toutes les requêtes des deux
listes d'entrée, dont les villes d'origine sont les mêmes, ainsi que leurs villes de
destination.

Par exemple, si A est une demande qui figure dans la première liste, avec la ville
d'origine Puebla et la destination CDMX, et que B est à son tour une demande de
la deuxième liste, également avec l'origine Puebla et la destination CDMX, les
deux demandes, A et B, Ils doivent figurer dans la liste renvoyée par la méthode
ou la fonction.

Programme conçu :

#include<iostream>
#include<string.h>
#définir vrai 1
#définir faux 0
en utilisant l'espace de noms std ;

requêtes de structure typedef

{
origine du caractère carbonisé[20] ;
destination du caractère[20] ;
identifiant de caractère[20] ;

4
}Application;

structure typedef{
Demande S[1000] ;
int dernier ;
}Liste;

void initialize(Liste &l);

void insert(Liste *l,Requête S);
partage nul (Liste &A, Liste &B, Liste *C, Demande S);
void print(Liste l);
void void(Liste &l);

int main()
{
Liste A, B, C ;
Demande Aux ;
int opt,retour;

initialiser(A);
initialiser(B);
initialiser(C);

faire{
cout<<"\n\t\tListes de requêtes"<<endl;
cout<<"\n\t1 - Insérer dans la liste A";
cout<<"\n\t2 - Insérer dans la liste B";
cout<<"\n\t3 - Partager des listes";
cout<<"\n\t4 - Supprimer la liste A";
cout<<"\n\t5 - Supprimer la liste B";
cout<<"\n\t6 - Afficher les listes";

5
 cout<<"\n\t0 - Quitte le programme";
cout<<"\n\tSélectionnez l'option : ";
cin>>opter ;
fflush(stdin);
si(opc==1||opc==2||opc==3)
{
si(opt==3)
{
cout<<"Entrez la Source et la destination qui partageront la liste des
requêtes";
}
cout<<"\nEntrez Origine :";
cin>>aux.origine;
cout<<"\nEntrez la destination :";
cin>>aux.destination;
si (opt! = 3)
{
cout<<"\nEntrez l'ID :";
cin>>aux.id;
}
autre
{
strcpy(aux.id,"NULL");
}
}

changer (opter) {
cas 1:
insérer(&A,aux);
cout<<"\nLIST TO:";
imprimer(A);

6
casser;
cas 2 :
insert(&B,aux);
cout<<"\nLISTE B:";
imprimer(B);
casser;
cas 3 :
initialiser(C);
partager(A,B,&C,aux);
casser;
cas 4 :
vide(A);
casser;
cas 5 :
vide(B);
casser;
cas 6 :
cout<<"\nLIST TO:";
imprimer(A);
cout<<"\nLISTE B:";
imprimer(B);
cout<<"\nLIST C:";
imprimer(C);
casser;
défaut:
si(opt==0){
cout<<"\n\t\tQuittez le programme. Au revoir !!\n\n";
renvoie 0 ;
}
autre{
cout<<"\n\t\t** Option hors plage. Essayer à nouveau. **\n"<<endl;

7
 }
casser;

}
} while (opter);

renvoie 0 ;
}

void initialize(Liste &l){

l.dernier = -1 ;
}

void insert(Liste *l,Requête S){

int je;
si(l->dernier==-1)
{
l->dernier = 0 ;
}
strcpy(l->S[l->last].destination,S.destination);
strcpy(l->S[l->last].origin,S.origin);
strcpy(l->S[l->last].id,S.id);
l->dernier++;
cout<<"\n\tIl a été inséré :"<<S.id<<endl;
}

void print(Liste l){

entier je = 0 ;
si(l.dernier==-1)
{

8
 cout<<"\n\tListe vide."<<endl;
retour;
}

while(i<l.dernier){
cout<<"\n"<<"ID:"<<lS[i].id<<" O:"<<lS[i].origin<<" D:"<<lS[i].destination< <"\
n"<<endl;
je = je + 1 ;
}
}

void void(Liste &l){

si(l.dernier = -1){
cout<<"\n\tTous les éléments ont été supprimés."<<endl;
}
autre{
cout<<"\n\tIl n'y a aucun élément dans la liste."<<endl;
}
}
partage nul (Liste &A, Liste &B, Liste *C, Demande S)
{
int je=0,j=0,tour=1,tours,t=0;

tours = A.dernier + B.dernier ;

pendant que(t<tours)
{
if(turn == 1)//REVUE LISTE A
{

9
if(strcmp(AS[i].origin,S.origin)==0&&strcmp(AS[i].destination,S.destination)==0)
{
insérer(C,AS[i]);
tour = 2 ;
}
je++;

}
sinon //REVISER LA LISTE B
{

if(strcmp(BS[j].origin,S.origin)==0&&strcmp(BS[j].destination,S.destination)==0)
{
insérer(C,BS[j]);
décalage = 1 ;
}
j++;
}
t++ ;
si(i==A.dernier&&j<B.dernier)
{
décalage=2 ;
}
si(j==B.dernier&&i<A.dernier)
{
décalage=1 ;
}

10
}

11
12
13
14
15
16
17