Introduction

26 January 2024 14:38

• Une liste linéaire est une représentation informatique d'un ensemble fini, de taille variable et
eventuellement nulle et ordonnée d'éléments de type T. Mathématiquement on peut définir une
liste linéaire ou en énulerant ses éléments dans l'ordre.
Exemple : LL = (t1,t2,t3,t4).
• Pour la SD Pile, les adjonctions (empiler), les supressions (depiler) et les recherches (dernier) sont
faites par rapport au sommet.
• Pour la SD file, les adjonctions (enfiler) sont faites par rapport à la queue, les suppressions (defiler)
et les recherches (premier) sont faites par rapport à la tête.
• Pour la SD liste linéaire, les adjonctions, les supressions et les recherches ne sont pas faites
systématiquement par rapport aux éléments en tête et en queue.

Les Opérations définies sur la SD LL :

Les opérations atomiques ou élémentaires :

- Création d'une LL vide.
- Tester est-ce que une LL est vide ou non.
- Adjonctions d'un nouveau élement à la LL.
- Supression d'un élément de la LL.
- Recherche d'un élement dans la LL.
- Visiter tous les élements de la SD LL en effectuant une opération (action) donnée.

Les opérations élaborées :

- Supression de tous les éléments d'une LL.
- Inversion d'une LL.
- Concaténation de 2 LL.
Exemple : LL1 = (a,b,c) ; LL2 (z,y,x) => concat(LL1,LL2) = (a,b,c,z,y,x)

Les listes linéaires Page 1

Représentation algorithmique Représentation chainée :
26 January 2024 15:39

dernier

On distingue la représentation contigüe et la représentation chainée.

Représentation contigue : premier

clé suivant
LL =(a,b,c,d) :
a b c d Les adjonctions et les supressions dans une liste linéaire matérialisée par une représentation chainée
ne posent pas des problèmes d'éfficacité.
Recherche :
Dans une liste linéaire, matérialisée par une représentation contigüe, Variantes de la SD Liste linéaire :
c'est équivalent à la recherche dans un tableau.
1.
Deux algorithmes peuvent être utilisés :
-algorithme de recherche séquentielle.
-algorithme de recherche dichotomique. premier

clé suivant
Adjonction :
LLinitiale :
On constate que l'élément qui occupe la première position dans la liste linéaire est priviligié.
a b c d
--Besoin d'ajouter X après b. 2.
LLfinale :
a b x c d
→ une telle opération nécessite de décalage;
→ une opération de décalage est couteuse en temps.
clé suivant
Supression :
--Supprimer l'élément b.
On constate que les deux éléments premier et dernier sont privilègiés.
LLinitiale :
a b c d  (1) et (2) proposent des listes linéaires unidirectionnelle, c'est à dire elles peuvent être parcourue
LLfinale : dans un seul sens : de gauche à droite.
a c d

3.
La supression (bien entendu logique) dans un tableau nécessite de
Liste linéaire bidirectionnelle qui offre la possibilité de parcourir la liste linéaire dans les deux sens :
décalage pour récupérer la position rendue disponible.
de gauche à droite et de droite à gauche.
Ici, les décalage sont faites à gauche.

Supression :
→ en tête.
→ au milieu.
→ en queue.

Conclusion :
La représentation contigüe ne peut pas être recommendée pour les 4.
listes linéaires de taille plus ou mois importantes ou variable.
Listes linéaires circulaires ou anneaux.
(car la complexité temporelle des opérations atomiques est о[n])

point d'entrée

-Dans un anneau (ou liste linéaire circulaire), les 2 notions de premier et dernier disparaissent, c'est à
dire elles n'ont pas de sens.
-Un anneau est doté uniquement d'un point d'entrée.
-Un anneau peut être bidirectionnel.

Les listes linéaires Page 2

Programmation en C
26 January 2024 16:10

Adjonction :
On va se contenter de réaliser en C quelques les opérations applicables sur la SD LL.
Hypothèse : insérer :
- Type d'élement : entier. → insérer après un élement référencé.
- Variante 2 : représentation chainée. → insérer avant un élément référencé.
Premier et dernier élément privilégié. → insérer avant premier.
→ insérer après dernier.
Représentation physique :
insérer après un élément référencé :
void inserer_apres(struct noeud * p, int info)
Création d'une liste linéaire
{
struct noeud
struct noeud *q;
{
q=(struct noeud *)malloc(sizeof(struct noeud));
int cle;
q->cle=info;
struct noeud * suivant;
q->suivant=p->suivant;
};
p->suivant=q;
struct liste
}
{
struct noeud * premier;
struct noeud * dernier; insérer avant un élément référencé :
}; void inserer_avant(struct noeud * p, int info)
{
struct noeud *q;
Création : q=(struct noeud*)malloc(sizeof(structnoeud));
Solution1: q->cle=p->cle;
Sous forme d'une procédure q->suivant=p->suivant;
void creer_liste(struct liste * ll) p->cle = info;
{ p->suivant = q;
ll->premier=NULL; }
ll->dernier=NULL;

} insérer avant premier :

void insérer_avant_premier(struct liste * ll, int info)
Solution2: {
Sous forme d'une fonction struct noeud *q;
struct liste * creer_liste() q=(struct noeud*)malloc(sizeof(structnoeud));
{ q->suivant=ll->premier;
struct liste * ll; ll->cle=info;
ll = (struct liste *)malloc(sizeof(struct liste)); if(liste_vide(ll))
ll->premier=NULL; ll->dernier=q;
ll->dernier=NULL; ll->premier=q;
} }

insérer après dernier :

Liste Vide ? : void insérer_apres_dernier(struct liste * ll, int info)
Solution 1: {
struct noeud * p;
unsigned liste_vide(struct liste *ll) p = (struct noeud*)malloc(sizeof(struct noeud));
{ p->cle = info;
return(ll->premier==NULL); p->suivant = NULL;
} if(ll->premier==NULL)
ll->premier = p;
Solution 2: ll->dernier->suivant = p;
unsigned liste_vide(struct liste *ll) ll->dernier = p;
{ }
return((ll->premier==NULL) && (ll->dernier==NULL));
}

Les listes linéaires Page 3

Opérations applicables sur une liste linéaire
09 February 2024 14:09

Processus de recherche dans une liste linéaire

Un problème de recherche a deux issus :
• positive
• négative
struct noeud * recherche(int info, struct noeud * p)
{
/*rend une référence non NULL si info appartient à une liste linéaire unidirectionnelle,en
partant de p sinon une reference NULL*/
/*on va adapter l'algorithme de recherche séquencielle d'une information dans un tableau*/
while ((p != NULL) && (p->cle != info))
p = p->suivant;
return(p);
}
Opération de Parcours
visiter tous les éléments d'une liste linéaire en effectuant un traitement donné.
Rappel sur les paramètres formels en C : Utilisation de la procédure du parcours :
• paramètres formels non fonctionnels : il s'agit d'un paramètre qui mémorise une valeur (ordinaire, adresse) /*paramètres effectifs*/
• paramètres formels fonctionnel : ils mémorisent un comportement (ou un traîtement) traduit par un sous programme struct noeud * point_depart;

les sous programmes qui admettent des paramètres fonctionnels s'appelent des sous -programmes d'ordre supérieur. Affichage :
void affiche(struct noeud * q)
Quels sont les paramètres nécessaires à l'opération de parcours ? {
a. paramètres non fonctionnels printf("%d\n",q->cle);
ils indiquent le point de départ pour traverser la liste }
struct noeud * p; /*activation du spg parcours*/
b. paramètres fonctionnels parcours(point_depart, afficher);
ils indiquent le traîtement à effectuer sur les noeuds visités
void(*oper)(struct noeud *); En C, le nom d'un sous-programme est considéré
comme un pointeur. Toute référence à (*oper) au
oper est un pointeur sur une procédure exigeant un paramètre de type struct noeud * . sein de la partie executive du sous-programme est
à ne pas confondre : void * oper(struct noeud *) une référence au paramètre effectif correspondant.
C'est le principe d'indirdrection.
il s'agit d'une fonction appelée "oper" qui rend un pointeur sur n'importe quoi et qui exige un paramètre de type struct noeu d *.
Incrémentation :
void parcours(struct noeud *p, void(*oper)(struct(noeud*)) le traîtement consiste à incrémenter tous les
{ éléments.
while(p) struct * point_depart;
{ void incrémenter (struct noeud *q)
(*oper)(p); {
p = p->suivant; q->cle++;
} }
} parcours(point_depart, incrementer);

Les listes linéaires Page 4

 Matrices creuses
09 February 2024 16:08

On a intérêt à trier par ordre croissant les listes lignes[i] sur le champ
trouver une représentation informatique des matrices creuses. colonnes.
une matrice creuse est une matrice qui comporte un nombre important
d'éléments nuls. #define n 100
La représentation souhaitée doit stocker uniquement les éléments non struct element
nuls. {
unsigned col;
#define n 100 exemple m : float info;
float m [n][n] 0 0 0 0 0 struct element * suivant;
}
0 0 1 0 3
Solution : accès rapide
ou direct sur la ligne 0 0 0 0 0 struct element * ligne[n];
0 0 1 4 0
une matrice creuse représentée ci-dessus peut être assimilée à une structure
0 0 0 0 0 de données.
Opérations applicables sur la matrice creuse :
lignes[0], lignes[2] et lignes[4] ne comportent pas des éléments non nuls. 1. opération de création
2. accés à un élément identifié par le couple (i,j)
lignes : exemple : a = m[i][j];
3. modification d'un élément donné
exemple : m[i][j] = 0;
0 1 2 3 4

2 1
col info

2 1
4 3

la colonne appartenant à une ligne i est obtenue par

une recherche séquentielle au sein de la liste lignes[i]

3 4

Les listes linéaires Page 5