Version de septembre 2005

Programmation avec DELPHI

Algorithmes obligatoires en
re
classe de I B pour 2005-2006

1/11
 Table des matières
1 Mathématiques élémentaires ....................................................................................................3
1.1 Fonction « puissance à exposant naturel non nul »..........................................................3
1.2 Fonction « puissance rapide à exp. naturel non nul » ......................................................3
1.3 Fonction « factorielle » ....................................................................................................3
1.4 Fonction « pgcd ».............................................................................................................4
1.5 Nombre premier ?.............................................................................................................4
2 Polynômes ................................................................................................................................5
2.1 Addition............................................................................................................................5
2.2 Multiplication ...................................................................................................................5
2.3 Dérivée .............................................................................................................................5
2.4 Primitive ...........................................................................................................................5
2.5 Schéma de Horner ............................................................................................................6
3 Algorithmes de tri.....................................................................................................................7
3.1 Tri par selection: solution récursive .................................................................................7
3.2 Tri par selection: solution itérative...................................................................................7
3.3 Tri par insertion : solution récursive ................................................................................7
3.4 Tri par insertion : solution itérative..................................................................................8
3.5 Tri rapide : solution récursive ..........................................................................................8
3.6 Tri rapide : fonction auxiliaire « division »......................................................................8
3.7 Tri par fusion : procédure « fusion »................................................................................9
3.8 Tri par fusion : version récursive .....................................................................................9
3.9 Tri par fusion : version itérative.......................................................................................9
4 Algorithmes de recherche.......................................................................................................10
4.1 Recherche séquentielle...................................................................................................10
4.2 Recherche dichotomique récursive ................................................................................10
4.3 Recherche dichotomique itérative..................................................................................10
4.4 Fréquence d’un élément dans une liste ..........................................................................11
4.5 Minimum dans une liste d’entiers non vide ...................................................................11
4.6 Maximum dans une liste d’entiers non vide...................................................................11

2/11
1 Mathématiques élémentaires
1.1 Fonction « puissance à exposant naturel non nul »
Version itérative
function puissance(base:real;expo:integer):real;
var i:integer;
p:real;
begin
p:=1;
for i:=1 to expo do p:=p*base;
puissance:=p;
end;

Version récursive
function puissance(base:real;expo:integer):real;
var i:integer;
p:real;
begin
if expo=1 then puissance:=base
else puissance:=base*puissance(base,expo-1)
end ;

1.2 Fonction « puissance rapide à exp. naturel non nul »

function puissrapid(base:real;expo:integer):real;
var i:integer;
p:real;
begin
if expo=1 then puissrapid:=base
else if (expo mod 2)=0 then
puissrapid:=puissrapid(base*base,expo div 2)
else
puissrapid:=base*puissrapid(base,expo-1)
end ;

1.3 Fonction « factorielle »

function factorielle(n:integer):integer;
var i,fact:integer;
begin
fact:=1;
for i:=2 to n do fact:=fact*i;
factorielle:=fact;
end;

3/11
1.4 Fonction « pgcd »
Algorithme d’Euclide par soustraction
function euclide_diff(a,b:integer):integer;
begin
while a<>b do
begin
if a>b then a:=a-b;
if b>a then b:=b-a
end;
result:=a;
end;

Algorithme d’Euclide par division

function euclide_divi(a,b:integer):integer;
var c:integer
begin
if b>a then begin c:=a;a:=b;b:=c end;
while b>0 do
begin
c:=a mod b;
a:=b;
b:=c
end;
result:=a;
end;

1.5 Nombre premier ?

function premier(n:integer):boolean;
var c,i : integer;
prim : boolean;
begin
if (n mod 2)=0 then premier:=false
else
begin
i:=3
prim:=true;
while ((i*i)<=n) and prim do
begin
if (n mod i)=0 then prim:=false;
i:=i+2;
end
end;
end;

4/11
2 Polynômes
Type poly = array [0..100] of integer ;
Les variables da, db, dc désignent les degrés des polynômes a, b, c.

2.1 Addition
procedure somme(var a,b,c:poly; var da,db,dc:integer);
var i,j:integer;
begin
if da<=db then
begin
for i:=0 to da do c[i]:=a[i]+b[i];
for i:=da+1 to db do c[i]:=b[i];
end
else
begin
for i:=0 to db do c[i]:=a[i]+b[i];
for i:=db+1 to da do c[i]:=a[i];
end;
while (dc>0) and (c[dc]=0) do dc:=dc-1;
end;

2.2 Multiplication
procedure produit(var a,b,c:poly; var da,db,dc:integer);
var i,j:integer;
begin
dc:=da+db;
for i:=0 to dc do c[i]:=0;
for i:=0 to da do
for j:=0 to db do c[i+j]:=c[i+j]+a[i]*b[j];
end;

2.3 Dérivée
procedure derivee(var a,c:poly; var da,dc:integer);
var i:integer;
begin
for i:=1 to da do c[i-1]:=a[i]*i;
if da=0 then begin dc:=0;c[0]:=0 end
else dc:=da-1;
end;

2.4 Primitive
La procédure donne la primitive à terme constant 0.
procedure primitive(var a,c:poly; var da,dc:integer);
var i:integer;
begin
c[0]:=0;
for i:=0 to da do c[i+1]:=a[i]/(i+1);
if (da=0) and (a[0]=0) then dc:=0 else dc:=da+1;
end;

5/11
2.5 Schéma de Horner
function horner(var a:poly; da:integer; x:real):real;
var i:integer;
px:real;
begin
px:=a[da];
for i:=da-1 downto 0 do px:=px*x+a[i];
horner:=px;
end;

6/11
3 Algorithmes de tri
3.1 Tri par selection: solution récursive
procedure tri_selection_r(var liste:TListbox; debut:integer);
var
j,min:integer;
begin
min:=debut;
for j:=debut+1 to liste.Items.Count-1 do
if liste.Items[j]<liste.Items[min] then min:=j;
echange(liste,debut,min);
if debut < liste.Items.Count-2 then
tri_selection_r(liste,debut+1);
end;

3.2 Tri par selection: solution itérative

procedure tri_selection_i(var liste:TListbox);
var
i,j,min:integer;
begin
for i:=0 to liste.Items.Count-2 do
begin
min:=i;
for j:=i+1 to liste.Items.Count-1 do
if liste.Items[j]<liste.Items[min] then min:=j;
echange(liste,i,min);
end;
end;

3.3 Tri par insertion : solution récursive

procedure tri_insertion_r(var liste: TListbox;gauche,droite:integer);
var j:integer;
candidat:string;
begin
if gauche<droite then
begin
tri_insertion_r(liste,gauche,droite-1);
candidat:=liste.Items[droite];
j:=droite;
while (j>0) and (liste.Items[j-1] > candidat) do
begin
liste.Items[j]:=liste.Items[j-1];
j:=j-1;
end;
liste.Items[j]:=candidat;
end;
end;

7/11
3.4 Tri par insertion : solution itérative
procedure tri_insertion_i(var liste:TListbox);
var i,j:integer;
candidat:string;
begin
for i:= 1 to liste.Items.Count-1 do
begin
candidat:=liste.Items[i];
j:=i;
while (j>0) and (liste.Items[j-1] > candidat) do
begin
liste.Items[j]:=liste.Items[j-1];
j:=j-1;
end;
liste.Items[j]:=candidat;
end;
end;

3.5 Tri rapide : solution récursive

procedure tri_rapide_r(var liste:TListbox;g,d:integer);
var i:integer;
begin
if d>g then
begin
i:=division(liste,g,d);
tri_rapide_r(liste,g,i-1);
tri_rapide_r(liste,i+1,d);
end;
end;

3.6 Tri rapide : fonction auxiliaire « division »

function division(var liste: TListbox;g,d:integer):integer;
var i,j : integer;
candidat :string;
begin
candidat:=liste.Items[d];
j:=d-1; i:=g;
while i<=j do
begin
if liste.Items[i]< candidat then i:=i+1
else if liste.Items[j]> candidat then j:=j-1
else begin echange(liste,i,j); i:=i+1 ; j:=j-1; end;
end;
echange(liste,i,d);
result:=i;
end;

8/11
3.7 Tri par fusion : procédure « fusion »
procedure fusion(var liste: TListbox; g,m,d: integer);
var i,j,k : integer;
tt : array[1..1000] of string; {mieux: déclarer tt globalement}
begin
for i:=g to m do tt[i]:=liste.Items[i];
for j:=m+1 to d do tt[d+m+1-j]:=liste.Items[j];
i:=g; j:=d;
for k:=g to d do
if tt[i]<tt[j]
then begin liste.Items[k]:=tt[i]; i:=i+1 end
else begin liste.Items[k]:=tt[j]; j:=j-1 end;
end;

3.8 Tri par fusion : version récursive

procedure tri_fusion_re(var liste: TListbox;g,d:integer);
var m:integer;
begin
if g<d then
begin
m:=(g+d) div 2;
tri_fusion_re(liste,g,m);
tri_fusion_re(liste,m+1,d);
fusion(liste,g,m,d);
end;
end;

3.9 Tri par fusion : version itérative

procedure tri_fusion_it(var liste: TListbox);
var i,m,step:integer;
begin
m:=liste.Items.Count;
step:=1;
i:=0;
while step<m do
begin
while (i+2*step-1)<m do
begin fusion(liste,i,i+step-1,i+2*step-1) ; i:=i+2*step; end;
if (i+step)<=m then fusion(liste,i,i+step-1,m-1);
{s'il reste une liste et une partie d'une 2e liste}
step:=step*2;
i:=0 ;
end;
end;

9/11
4 Algorithmes de recherche
4.1 Recherche séquentielle
function recherche_seq_i(liste:TListbox;cle:string):integer;
var
index:integer;
begin
index:=0;
while (index <= liste.Items.Count-1) and (liste.Items[index]<>cle) do
index:=index+1;
if index <= liste.Items.Count-1 then result:=index
else result:=-1;
end;

4.2 Recherche dichotomique récursive

function dicho_r(liste:TListbox;cle:string;g,d:integer):integer;
var
milieu:integer;
begin
if g>d then result:=-1
else
begin
milieu:=(g+d) div 2;
if liste.Items[milieu] = cle then result:=milieu
else if cle<liste.Items[milieu] then
result:= dicho_r(liste,cle,g,milieu-1)
else
result:= dicho_r(liste,cle,milieu+1,d);
end;
end;

4.3 Recherche dichotomique itérative

function dicho_i(liste:TListbox;cle:string):integer;
var
milieu,g,d:integer;
begin
g:=0;
d:=liste.Items.Count-1;
while (cle<>liste.Items[milieu]) and (g<=d) do
begin
milieu:=(g+d) div 2;
if cle<liste.Items[milieu] then d:=milieu-1
else g:=milieu+1;
end;
if cle=liste.Items[milieu] then result:=milieu
else result:=-1;

10/11
end;

4.4 Fréquence d’un élément dans une liste

function frequence(liste:TListbox;cle:string):integer;
var
index,freq:integer;
begin
freq:=0;
for index:=0 to liste.Items.Count-1 do
if liste.Items[index]=cle then freq:=freq+1;
result:=freq;
end;

4.5 Minimum dans une liste d’entiers non vide

function minimum(liste:TListbox):integer;
var
index,mini:integer;
begin
mini:= liste.Items[0];
for index:=1 to liste.Items.Count-1 do
if liste.Items[index]<mini then mini:= liste.Items[index]
result:=mini;
end;

4.6 Maximum dans une liste d’entiers non vide

function maximum(liste:TListbox):integer;
var
index,maxi:integer;
begin
maxi:= liste.Items[0];
for index:=1 to liste.Items.Count-1 do
if liste.Items[index]>maxi then maxi:= liste.Items[index]
result:=maxi;
end;

11/11