LABO MATHS-INFO

CHAP1
STRUCTURE DE DONNEES LINEAIRES

--- TABLEAU ET COMPLEXITE ----

Une structure de donnée est une représentation de l’information (donnée) en vue

de son implémentation dans un langage de programmation.

Une structure de donnée est complètement implementée par un titre abstrait ie ensemble de
donnée et d’operations appllicables a ces données.

Une structure linéaire est une structure qui a la caractéristique fondamentale de definir une
fonction ‘’successeur’’ qui a chaque élément de la structure(sauf éventuellement le dernier) fait
correspondre un autre élément de la même structure. Dans une structure linéaire, les éléments sont
contigus(les uns à la suite des autres).
étudiant complexe
-Nom
- Prenom - Réel
- Matricule - imaginaire
- filiere

e e e e e e
E1 E2 E3
Les tableaux Les listes chainées

La complexité d’un algo représente la quantité de ressources(temps, nombres

d’instructions, espaces mémoires...) nécessaires à l’éxecution de cet algo.

La compléxité est determinée de manière formelle suivant les différentes approches :

- Le temps de calcul dans le pire des cas.

- Le temps de calcul dans le moyen des cas.
- Le temps de calcul dans le meilleur des cas.

La compléxité en temps est donnée sous la forme d’un ordre de grandeur sur le temps telle que
resumé dans le tableau ci-après.

Temps Complexité
O(1) Constante
O(log(n)) Logarithmique
O(√n) Racinaire
O(n) Linéaire
O(n2) Quadratif
O(n3) cubique
Tableaux :
Définition : <>

Un tableau est une collection d’objets de même nature ou type qui a :

- Une taille fixe lors de sa création ;

- Un type défini lors de sa création(le type de ses éléments) ;
- Les objets sont indicés par des valeurs allant de 0 à la taille -1 ;

On distingue :

- Les tableaux à une dimension(vecteurs)

- Les tableaux à deux dimensions(matrices)
- Les tableaux à n dimension(n>2)

Les tableaux à une dimension(vecteurs)

1 2 3 4 5 6

Declaration d’un tableau Cellule ou case

Syntaxe : TypeT nomT[taille] ;

Exemple : int t[10] ;

Pour faire le parcours d’un tableau, on a besoin d’une boucle « for ».

Exemple :
For(i=0 ;i <=6 ;i++){
For(i=0 ;i <=6 ;i++){
Printf(‘’%d’’, tab[i]) ;
Scanf(‘’%d’’, &V) ;
}
Tab[i]=V ;

Recherche séquentielle dans un vecteur

Cette opération suppose que l’élément cherché apparait au plus une et une seule fois dans
un vecteur.Le parcours s’arrête dans 02 cas :

- Soit dès qu’on a trouvé l’élément cherché

- Soit dès qu’on aura rencontré le dernier élément
La fonction qui permet rechercher un élément dans un tableau :

Int search(int t[], int N, int V)

Int i = 0 ;

Int trouve = 0 ;

While(i <N && trouve = 0)

If(t[] == V){

Trouve = 1 ;

Break ;

i++ ;

Return trouve ;

instruction nombre coût

Affectation 3 C1
Incrémentation n–1 C2
Choix
comparaison n C3

T(n) = nC3 + (n-1)C2 + 3C1

= n(C3 + C2) + 3C1 – C2

T(n) = an + b D’où T(n) = O(n)

Le jour qu’on trouve i à la derniere position, l’on n’incrémente plus.

L’on comprend que l’équation de complexité de

la recherche séquentielle est linéaire.
Continue : saute l’indice par exemple il saute un cas et continue l’instruction
suivante.

Break : sort de la boucle.

Recherche dichotomique dans un vecteur

Elle se fait sur un tableau trié. Cela consiste à considérer une certaine
plage de recherche(inf...sup) sur la vecteur plage que l’on réduit d’un facteur 2
à chaque itération.

Au départ, la plage de recherche est tout le vecteur. A une itération donnée, on

a une plage[inf...sup] et son milieu est

On a donc la subdivision : [inf......m-1][m][m+1........sup]

03 situations se presentent :

- Soit vec[m] = V
- Soit vec[m] sup V, v € [inf..........m-1]
- Soit vec[m] inf V, v € [m+1.......sup]

0 1 2 3 4 5 6 7 8

Vec 10 20 30 40 50 60 70 80 90
Int V = 70

m = (0+8)/2 = 4

10 20 30 40 50 60 70 80 90

on a alors vec[m] inf v

60 70 80 90

m = (5+8)/2

=6
 V € [inf............m-1]

V € [m+1............sup]

Int dichotomie (int vec[], int V, int inf, int sup) {

Int m ;
If(inf inf sup) {
m = (inf+sup)/2 ;
if(vec[m] == V)
return 1 ;
else if(vec[m] inf V) {
dichotomie(vect, V, m+1, Sup) ;
} else
Dichotomie(vect, V, inf, m-1) ;
} else
Return O ;
} L’on comprend que l’équation de complexité de la recherche
dichotomique est logarithmique O(log(n)). Car à chaque
itération, on divise le tableau en 2.

T(n) = T(n/2) + 1
Les tableaux à deux dimensions(matrices)

Syntaxe : TypeM nomM [taille1] [taille2] ;

Exple :

#define NBL 5

#define NBC 4

Int Mat[NBC][NBC]

Il est possible d’initialiser une matrice lors de sa création.

Exple :

Int Mat [NBL] [NBC] = {{1,1} ;{2,2,2,2}}

0 1 2 3

4
Parcours d’une matrice
Une matrice se parcourt à l’aide de deux boucles imbriquées :

For(i=0 ; i inf NBL ; i++)

For(j=0 ; j inf NBC ; j++)

Printf(‘’%d’’, mot[i][j]) ;

(0,0) (0,1) (0,2) (0,3) (0,4)

i++ varie n fois ie NBL
(1,0) (1,1) (1,2) (1,3) (1,4)

(2,0) (2,1) (2,2) (2,3) (2,4)

j++ varie n2 fois NBL*NBC

(3,0) (3,1) (3,2) (3,3) (3,4)

L’on comprend que l’équation de complexité de

ce bout de code est quadratif ie O(n2).
J++ s’éxecute n2 de fois et I++ n fois.
 LABO MATHS-INFO
CHAP2
LISTES SIMPLEMENT
CHAINEES
2.1. LES POINTEURS
a) Variable dynamique pointeur et adresse

Un objet P de type pointeur sert à designer des

objets : les valeurs qui’il prend sont des réferences(adresse
en memoires à ces objets. (ie qu’on use un pointeur que
lorsqu’on a envie de designer un autre objet)

Une variable dynamique (ou objet pointé) est un

objet crée pendant l’éxecution d’un programme. Elle a un
type et une valeur variable mais n’a pas de noms.

p
n+1
pointeur

Variable pointée
L’opérateur de puce d’adresse « @ » est un opérateur
unaire qui s’applique à une identification des variables.
Il ne s’applique pas à des constantes.
Exple :
int n ;

int t[N] ;

@n adresse de la variable n

@t[4] = adresse du 5ème element de t

@t = interdit
Déclaration de pointeur et adresse
Comme pour les tableaux, il n’existe pas de type pointeur en
C. Une variable pointeur est definie par un déclarateur
pointeur.
Exple :

Int *p ; // pointeur sur un objet de type entier.

Int *p[N] ; // tableau de N pointeur
Int (*p)[N] ; // pointeur sur un tableau

Le pointeur va servir à faire une indirection

(modifier une valeur et à la recuperer si possible).
Exple : x y
Int x=4, y=5 4 5

Int *P=@x
*P=@y P
P
POINTEURS ET TABLEAUX
Les déclarations suivantes sont equivalentes en ce sens que t
et P sont des chaînes de caractère :

Char t[N] char *P

t = ‘’une’’ et P = ‘’deux’’ alors
t[0] = ‘u’ *t = ‘u’
P[2] = ‘u’, *P = ‘d’

OPERATEURS POUR LES POINTEURS

- Un pointeur qui ne pointe sur rien a une

valeur NULL (Constante defini dans Stdio.h)
- Les affectations entre lles pointeurs ayantr
des objets pontés de meme type sont
possibles.
Exple : int *P1, *P2 ;
P1 = P2 ;

- Les opérations arithmétiques suivantes sont

définies sur les pointeurs.
*Addition : entre pointeur et entier =
déplacement (p+n=dep)
 *Soustraction : (p-n=dep)
*Comparaison de deux pointeurs : c’est une
relation d’ordre : reflexivité, transivité et
asymétrie.
*Void *P : pointeur universel.

Id[expr] = *(id +exp)

Exple : t[1] = *(t+1) or *t+1 représente
l’addition la valeur pointée et 1.
Int t[5] ={1,2,3,4,5}
*(t+2) = 3
*t+2=3
T[2]=3
For(i=0 ;i<=N ;i++) For(i=0 ;i<=N ;i++)

Scanf(‘’%d’’, *(t+i)) ; Scanf(‘’%d’’, *t[i]) ;

POINTEURS ET STRUCTURES
Soit le typedef struct{
Short j, m ;
Int a ;
}Date ;
La déclaration d’un pointeur sous cette structure est :

Date *d ;
L’accès à un champ du pointeur *d se définit par :
J m a
(*d).j = 2 ; 2 12 2016

(*d).m = 12 ;
(*d).a = 2016 ;

Le typage :
Type (d) = Date*

Type( *d) = Date

Type((*d).j) = short

On peur également se servir de pour acceder au champ d’une

structure.

D j=2

D m = 12 D a = 2016
 STRUCTURES DE DONNEE LISTE

L 1 2 3

Une liste est une suite d’un nombre variable d’objets appelés
ELEMENTS DE LISTE. Une liste simplement chaînée est
une liste dans laquelle chaque élément sauf le dernier pointe vers
son successeur.

1 2 3

Liste bilatere

1 2

Pour definir une liste simplement chainée, il faut :

- Décrire le type de ces éléments qui est generalement un

enregistrement constitué de 02 parties : une partie
information et un pointeur qui reference l’élément suivant.
- Définir un pointeur de ttête quin permet d’acceder aux 1ers
elements de la liste châinée.
Exple : Lch

Typedef struct cellule{

Int info ;

Struct cellule *next ;

} *listeEntiere ;

infos next

Listeentier P ;

cellule

PARCOURS D’UNE LISTE

Afficher une liste, revient à afficher les differentes parties de la

liste(partie info).
Soit la liste d’entiers P.

10 20 30
Void Parcours( ListeEntier l) {

ListeEntier p = l ;

While( p next != NULL) {

Printf(‘’%d’’, p info ) ;

P=p next ;

Printf(‘’%d’’, P info) ;

}
INSERTION DANS UNE LISTE

- Insertion en tête

L 12 12
Créons la nouvelle cellule a insérer :

new 2

L 12 12
une fois que la liste est crée, 02 conditions se precisent :
Créer une nouvelle
new 2 cellule, c’est
fabriquer une
si la liste est vide, l’on retourne la nouvelle cellule. nouvelle liste
Sinon, proceder à l’insertion de la cellule dans la liste suivant ce schéma :
ListeEntier insertête(ListeEntier l , int V) {

New info = V ;

New next = NULL ;

If(l==null)

Return new ;

Else {

New next = l ;

L = new ;

Return l ;
 LISTES CHAINEES SUITE

1 2 3

Typedef struct cellule{ info next

Typedef cellule *listeEntier
Int info ;
Ou }listeEntier à la fin de la
définition Struct cellule *next ;
Une structure listeEntière
} *listeEntier ;
qui pointe vers une cellule

Ce que nous pouvons faire sur une liste, il ya :

LE PARCOURS D’une LISTE

C’est se posiionner sur le 1er elt et rechercher le dernier elt

Void Parcours( ListeEntier P) {
Voici ce qui nous permet
ListeEntier p = ptr ; de parcourir la liste.

While( p next != NULL) {

Printf(‘’%d’’, p info ) ;

P=p next ;

P2 next = P ;

n+1
P=P;
P Return P ;
P2
Malloc : allocation d’espace en mémoire.

INSERTION DANS UNE LISTE

ListeEntier insertête(ListeEntier p , int V) {

ListeEntier P2 ;

P2 = malloc(sizeof(structCellule)) ; // allocation dynamique de la mémoire

P2 info = V ;

P2 next = NULL ;

If(P == null)

Return P2 ;

Else {

P2 next = P ;

P=P;

Return P ;

}
 P2
- Insertion en Queue

P 12

P2 1 2

- ListeEntier insertQueue(ListeEntier P, int V) {

ListeEntier P2, inter = P ;
- P2 = malloc(sizeof(structCellule)) ;
- P2 info = V ;
- P2 next = NULL ;
- while(inter inter != null)
- Inter = inter next ;
Inter next = P2 ;
-
- Return P ;

P1 = P

P=P next
SUPPRESSION DANS UNE LISTE
P1 next = null

Free(P1)
P2
P2 next = 3

NULL

P 1 2 3

Free(P1)