1

Structures de donnes et algorithmes examen (2h)

Ex1 (1 pt). Considrez le programme suivant. crivez les valeurs sur la pile chaque tape et
les valeurs imprimes la console.

#include <iostream>
using namespace std;
#define NMAX 10

template<typename T>
class Stack {
private:
T stackArray[NMAX]; int topLevel;
public:
void push(T x) {
if (topLevel >= NMAX - 1)
{ cout<<"The stack is full: we have already NMAX elements!\n"; return;}
stackArray[++topLevel] = x;
}
int isEmpty() {return (topLevel < 0); }
T pop() {
if (isEmpty()) {cout<<"The stack is empty! \n"; T x; return x;}
return stackArray[--topLevel];
}
T peek() {
if (isEmpty()) {cout<<"The stack is empty! \n";T x;return x;}
return stackArray[topLevel];
}
Stack() { topLevel = -1;}
~Stack() {}
};

int main()
{
Stack<int> stack;
int item1 = 1;int item2 = 0;int item3 = 4;
stack.push(item2); stack.push(item1); stack.push(item1 + item3);
cout<<stack.pop()<<endl;
stack.push(item3*item3); stack.push(item2); stack.push(3);
stack.pop();
cout<<item1<<item2<<item3<<endl;
while (!stack.isEmpty())
{
stack.pop(); cout<<item1<<endl;
}
cout<<stack.peek();
return 0;
}

Ex2 (1 pt). Considrez une file d'attente vide Q implmente en utilisant un tableau circulaire
avec N= 5 positions (avec des indices 0, 1, 2, 3,4). Imprimez les valeurs stockes dans le tableau
circulaire et celles imprimes sur la console, lors de chaque tape.

Queue<char> q;
q.enqueue('A'); q.enqueue('F'); q.enqueue('H'); q.enqueue('S'); q.enqueue('L'); q.enqueue('b');
2

printf("Deque %c\n", q.dequeue()); printf("Deque %c\n", q.dequeue()); printf("Peek %c\n",
q.peek());
q.enqueue('X'); q.enqueue('y'); q.dequeue(); q.enqueue('k'); printf("Peek %c\n", q.peek());

Ex.3(0.5 pt). Considrez le programme suivant, o les adresses des variables x, y, z et t sont,
dans l'ordre, 4214800, 4214804, 4214808 et 4214812. Montrez ce que chaque instruction printf imprime
sur la sortie standard. Si vous considrez que vous n'avez pas assez d'informations pour dcider
certaines des valeurs imprimes par printf, puis expliquer pourquoi et choisir vos propres valeurs pour
ces cas.
#include <stdio.h>
int x = 1, y = 2, z = 3, t = 4;
int *p1, *p2, *p3, *p4, **pp;
int main()
{
p1 = &x; p2 = &y; p3 = &z; p4=&t; pp = &p4;
printf("%d %d %d %d %d %d %d %d %d %d
%d %d %d %d\n", x, y, z, t, *p1, *p2, *p3, *p4,
p1, p2, p3, p4, *pp, **pp);
return 0; }

Ex. 4 (2 pt)
a) Considerez un graphe orient avec
18 sommets (nuds), numrots de 0 17, et
la matrice d'adjacence suivante:
a1) Construisez le graphe. (0,5 pt)
a2) Considerez lalgorithme de parcours
en profondeur (DFS) partir de sommets: 17,
7, 10. Imprimez l'ordre dans lequel les sommets
(nuds) sont visits. S'il ya plusieurs
possibilits, alors vous pouvez imprimer
n'importe quel d'entre eux. ). Les voisins d'un
sommet sont considrs dans l'ordre croissant de leurs numros. Expliquez vos choix dans l'algorithme.
(1 pt)
b) Considerez le graphe rejoint. Considerez le parcours en
largeur (BFS partir de sommet (node) 3. Imprimer l'ordre dans
lequel les sommets (nuds) sont visits. ). Les voisins d'un sommet
sont considrs dans l'ordre croissant de leurs numros.Expliquez
vos choix dans l'algorithme. (0.5 pt).

Ex. 5 (1,5 p). Vous avez un arbre binaire de recherche
vide.
a) Insrez les lments et dessiner l'arbre aprs chaque
insertion: 130, 700, 800, 400, 90, 1000, 120, 900, 80, 125, 500, 750.
(0.50 p)
b) Sur l'arbre de recherche binaire obtenu au point a) nous
appelons find (x) (ou findInfo (x), ce qui est la mme chose) pour
plusieurs valeurs de x: 510, 750,120 . Pour chaque appel imprimez
la squence de noeuds d'arbre visits par cet appel (dans l'ordre
dans lequel ils sont rendus). (0.20 p)
c) De l'arbre de recherche binaire obtenu au point a) nous
retirons, dans l'ordre, les lments suivants: 900, 400, 800, 130, 125, 120. Dessinez l'arbre aprs chaque
enlvement de l'lment. Expliquez les rgles que vous avez utilis. (0.50 p)
d) Considrons l'arbre de recherche binaire obtenu au point c). Imprimez l'ordre dans lequel les
noeuds de l'arbre sont visits si nous utilisons: d1) le parcours en-ordre; d2) le parcours pre-ordre; d3) le
parcours post-ordre. Expliquez les rgles utilises par chacun des 3 traverses. (0.30 p)

3

Ex.6(1 p). Prenons un (min-) tas vide.
a) Nous insrons dans le tas, dans l'ordre, les lments suivants: 100, 90, 400, 700, 95, 500,
450, 10, 200, 300, 900, 5, 300. Dessinez le tas aprs chaque insertion de l'lment et expliquez chaque
tape. Indiquez le tableau utilis pour stocker le tas. (0.5 p)
b) Considrons le tas obtenu au point a). Nous extrayons la valeur minimale du tas 13 fois (autant
de fois qu'il ya d'lments dans le tas). Dessinez le tas aprs chaque extraction. (0.5 p)

Ex. 7 (0.5 p)
Utilisez les valeurs suivantes: 12;24;36;65;94;47;38;67. Stocker les valeurs dans une table de
hachage avec 29 postes, selon la mthode de division de hachage et de la mthode de sondage linaire
de rsoudre les collisions.

Ex. 8(0.5 p). Triez le tableau ci-dessous en utilisant Radix Trier. Expliquez l'algorithme.

Ex. 9 (1p). Considrons la classe suivante, ce qui reprsente un graphe:
template<typename TnodeInfo, typename TedgeInfo>
class Graph {
public:
int N;//dimmension
char **A; // matrice d'adjacence
TnodeInfo *nodeInfo; TedgeInfo **edgeInfo;
Graph(int numNodes) {} ~Graph() {....}
void setNodeInfo(int i, TnodeInfo info){...} TnodeInfo getNodeInfo(int i) {....}
void addEdge(int i, int j) {...} void removeEdge(int i, int j) {...}
void setEdgeInfo(int i, int j, TedgeInfo info) {...} TedgeInfo getEdgeInfo(int i, int j) {....}
}
crivez une fonction en C/C++ pour dterminer si un graphe est connexe ou non et appeler la
function pour un graph dfini par vous, dans une function main().

Ex. 10 (1p). Considrons la classe suivante, ce qui reprsente un arbre binaire de recherche:
template<typename T> class BinarySearchTree {
public:
BinarySearchTree<T> *root, *left_son, *right_son, *parent;
T *pinfo;
BinarySearchTree() {....} void setInfo(T info) {....}
void insert(T x) {....} BinarySearchTree<T>* find(T x) {....} void remove(T x) {...}
void inOrderTraversal() {...} void preOrderTraversal(){...} void postOrderTraversal(){..} }
Ajouter la classe BinarySearchTree <T> une method traversalSum qui renvoie une valeur de
type T ce qui reprsente la somme des valeurs des noeuds de l'arbre, multipli par la position du noeud
dans l'ordre dans lequel les nuds sont visits. Nous supposerons que le type T des valeurs des noeuds
est numriquement (par exemple, int ou double). Le premier argument de la fonction doit tre un int, ce
qui reprsente le type de parcours. La fonction peut avoir d'autres parameters:
T traversalSum(int traversal, ...) {...}
traversal = 1 => an parcours infixe; traversal = 2 => un parcours prfixe; traversal = 3 => an parcours
postfixe
Un nud p contribue la somme retourns avec (value(p) * position(p) ) o la value(p) est la
valeur stocke par le nud p et la position(p) est la position du nud dans l'ordre de traverse (les
positions sont numrotes de 1 au nombre de noeuds de l'arbre). La function est appele, tout comme
toutes les autres fonctions, la racine de l'arbre. Vous puissiez dfinir d'autres fonctions auxiliaries, si
vous avez besoin.