Sunteți pe pagina 1din 25

Algoritmi elementari

Metode de cutare
secvenial
binar
Metode de ordonare
metoda bulelor
metoda inseriei
metoda seleciei
metoda numrrii
Interclasare
Analiza complexitii unui algoritm
Metode de cutare
Datele se afl n memoria intern, ntr-un ir . Vom cuta un
element n ir i returnm poziia elementului cutat (dac acesta
exist).
Se d (date): un ir de numere i numrul care se caut
Se cere (rezultate): poziia elemetului n ir
Dac lucrm cu iruri ordonate este util s aflm nu numai dac
exist un element n ir ci i s sim n caz contrar locul n care ar
tre!ui inserat un nou element, astfel nc"t s se pstreze ordinea
existent.
Cutare secvenial
Ideea:
Verificm pe r"nd elementele din ir p"n c"nd sim
elementul cutat
Exemplu:
sir !" #" $" %" &
x $
'ezultat: &
sir !" #" $" %" &
x (
'ezultat: )!
Cutare secvenial ) Implementare *n C
/**
* cauta elementul x in sirul v
* returneaza pozitia elementului x in v
*/
int cautareSecventiala(int x, vector& v) {
int poz = -1;
int i = 0;
while (i < v.n && poz == -1) {
if (v.ei! == x) {
poz = i;
" else {
i##;
"
"
return poz;
"
Cutare secvenial ) Implementare *n +ascal
,unction caut#ec$($%$ector&x%integer)%integer&
var poz,i%integer&
begin
poz%'(&
i%')&
-.ile (i*'$.n) and (poz'() do
i, ($.e+i,'x) t.en poz%'i
else i%'i-)&
caut#ec$%'poz&
end&
Analiza complexitii unui algoritm
.utem analiza complexitatea unui aloritm n raport cu%
durata de execuie
cantitatea de memorie necesar&
/impul necesar executiei unui proram depinde de
numarul operaiilor ce tre!uie executate.
calculatorul (0ard1are), sistemul de operare, lim!a2ul folosit pentru
implementare, etc
3and analizam complexitatea ne raportam la numrul de operaii executate, acesta
depinde de datele de intrare
4naliz complexitii ne d ordinul lor de mrime a timpului de execuie (sau
spaiului utilizat) n raport cu dimensiunea datelor de intrare
Complexitate cutare secvenial: /(n)
Cutare binar
0oar pentru cutare *n 1ir ordonat
Ideea:
#e determin n ce relaie se afl elementul aflat n mi2locul
irului cu elementul ce se caut. 5n urma acestei $erificri cutarea
se continu doar ntr-o 2umtate a irului. 5n acest mod, prin
n2umtiri succesi$e se micoreaz $olumul irului rmas pentru
cutare
Exemplu:
sir ordonat !" $" %" #" 2
x $
'ezultat: !
sir ordonat !" $" %" #" 2
x (
'ezultat: &
Cutare binar ) Implementare *n C
/**
* cauta x in su$sirul st,%r!
*/
int cautBinar_rec(vector& v, int x, int st, int %r) {
if (st &= %r - 1) {
return %r;
" else {
int m = (st # %r) / ';
if (x <= v.em!) {
return caut(inar)rec(v, x, st, m);
" else {
return caut(inar)rec(v, x, m, %r);
"
"
"
/*
* v este or%onat crescator
* rezultatul e pozitia pe care apare x sau pe care ar tre$ui inserat x
*/
int cautBinar(vector& v, int x) {
if (x <= v.e0!) {
return 0;
"
if (x & v.ev.n - 1!)
return v.n;
else
return caut(inar)rec(v, x, 0, v.n - 1);
"
Cutare binar ) Implementare *n +ascal
,unction caut6inar7rec($%$ector&x,st,dr%integer)%integer&
var m%integer&
begin
i, (st8'dr-)) t.en begin
caut6inar7rec%'dr
end else begin
m%'(st-dr) di$ 9&
i, x*'$.e+m, t.en caut6inar7rec%'caut6inar7rec($,x,st,m)
else caut6inar7rec%'caut6inar7rec($,x,m,dr)&
end&
end&
,unction caut6inar($%$ector&x%integer)%integer&
:$ este ordonat crescator;
:rezultatul e pozitia pe care apare x sau pe care ar tre!ui inserat x;
var poz%integer&
begin
i, (x*'$.e+),) t.en poz%')
else
i, (x8$.e+$.n,) t.en poz%'$.n-)
else
poz%'caut6inar7rec($,x,),$.n)&
end&
Complexitate: /(log
&
n)
Metode de ordonare
<earan2are a unui ir de elemente aflate n memoria intern astfel
nc"t elementele s fie ordonate cresctor (e$entual descresctor).
0ate: un ir de elemente
'ezultate: =irul ordonat crescator (descresctpor)
Metoda bulelor

Ideea:
3ompar dou c"te dou elemente consecuti$e iar n cazul n care
acestea nu se afl n relaia dorit, ele $or fi intersc0im!ate.
.rocesul de comparare se $a nc0eia n momentul n care toate
perec0ile de elemente consecuti$e sunt n relaia de ordine dorit
Exemplu:
1ir: (" !" 3")!" &
'ezultat: )!" !" &" (" 3
Metoda bulelor ) Implementare *n C
/**
* sortare *olosin% meto%a $ulelor
*/
void sortareBule(vector& v) {
bool or%onat = false;
while (+or%onat) {
or%onat = true; //presupunem sirul este or%onat
for (int i = 1; i < v.n; i##) {
if (v.ei - 1! & v.ei!) {
//intersc,im$am
int aux = v.ei - 1!;
v.ei - 1! = v.ei!;
v.ei! = aux;
or%onat = false;
"
"
"
"
Metoda bulelor ) Implementare *n +ascal
procedure sort6ule(var $%$ector)&
var i,t%integer&
ordonat%boolean&
begin
repeat
ordonat%'true&
,or i%'9 to $.n do
i, $.e+i-),8$.e+i, t.en begin
t%'$.e+i-),&
$.e+i-),%'$.e+i,&
$.e+i,%'t&
ordonat%'false&
end&
until ordonat&
end&
Complexitate metoda bulelor: /(n
&
)
Metoda inseriei
Ideea:
tra$ersm elementele, inserm elementul curent pe poziia
corect n su!irul care este de2a ordonat. 5n acest fel elementele
care au fost de2a procesate sunt n ordinea corect. Dup ce am
tra$ersat tot irul toate elementele $or fi sortate.
Exemplu:
1ir: (" !" 3")!" &
'ezultat: )!" !" &" (" 3
Metoda inseriei ) Implementare *n C
/**
* sorteaza v
*/
void sortareInsertie(vector& v) {
for (int i = 1; i < v.n; i##) {
int in% = i - 1;
int x = v.ei!;
while (in% &= 0 && x < v.ein%!) {
v.ein% # 1! = v.ein%!;
in%--;
"
v.ein% # 1! = x;
"
"
Metoda inseriei ) Implementare *n +ascal
procedure sort>nsertie(var $%$ector)&
var i,2,ind,x%integer&
begin
,or i%'9 to $.n do begin
ind%'i-)&
x%'$.e+i,&
-.ile (ind8() and (x*$.e+ind,) do begin
$.e+ind-), %' $.e+ind,&
ind%'ind -)&
end
end
end&
Complexitate: /(n
&
)
Metoda seleciei
Ideea:
#e determin poziia elementului cu $aloare minim (respecti$
maxim), dup care acesta se $a intersc0im!a cu primul element.
4cest procedeu se repet pentru su!irul rmas, p"n c"nd mai
rm"ne doar elementul maxim.
Exemplu:
1ir: (" !" 3")!" &
'ezultat: )!" !" &" (" 3
Metoda seleciei ) Implementare *n C
/**
* sortare *olosin% meto%a selectiei
*/
void sortareSelectie(vector& v) {
for (int i = 0; i < v.n - 1; i##) {
//selectam minimul %in restul sirului
int min-oz = i;
for (int . = i # 1; . < v.n; .##) {
if (v.emin-oz! & v.e.!) {
min-oz = .;
"
"
//mutam minimul pe pozitia curenta
if (min-oz += i) {
int aux = v.emin-oz!;
v.emin-oz! = v.ei!;
v.ei! = aux;
"
"
"
Metoda seleciei ) Implementare *n +ascal
procedure sort#electie(var $%$ector)&
:selectia minimului;
var i,2,ind,t%integer&
begin
,or i%') to $.n-) do begin
ind%'i&
,or 2%'i-) to $.n do
i, $.e+2,*$.e+ind, t.en ind%'2&
i, i*ind t.en begin
t%'$.e+i,&
$.e+i,%'$.e+ind,&
$.e+ind,%'t&
end&
end&
end&
Complexitate: /(n
&
)
Metoda numrrii
Ideea:
#e da un sir de elemente distincte. .entru fiecare element
numarm elementele care sunt mai mici, astfel aflm poziia
elementului n irul ordonat.
Exemplu:
1ir: (" !" 3")!" &
'ezultat: )!" !" &" (" 3
Metoda numrrii ) Implementare *n C
/**
* sorteaza v
*/
void sortareNumarare(vector& v) {
//se *ace o copie a sirului
vector v' = v;
for (int i = 0; i < v.n; i##) {
//numaram cate elemente sunt mai mici
int nr/ai/ici = 0;
for (int . = 0; . < v.n; .##) {
if (v'.e.! < v'.ei!) {
nr/ai/ici##;
"
"
v.enr/ai/ici! = v'.ei!;
"
"
Metoda numrrii ) Implementare *n +ascal
procedure sort?umarare(var $%$ector)&
var i,@,2,x%integer&
$)%$ector&
begin
$)%'$&
,or i%') to $).n do begin
:numar cate elemente sunt mai mici decat $.e+i,;
@%'(&
x%'$).e+i,&
,or 2%') to $).n do
i, $).e+2,*x t.en @%'@-)&
$.e+@-),%'x&
end&
end&
Complexitate: /(n
&
)
Interclasare
Aiind date dou iruri de numere, ordonate cresctor (sau
descresctor), se cere s se o!in un ir care s fie de asemenea
ordonat cresctor (respecti$ descresctor) i care s fie format din
elementele irurilor date.
Ideea:
=irul rezultat se poate o!ine direct (fr o sortare a irului
final) prin parcurerea sec$enial a celor dou iruri, simultan cu
enerarea irului cerut. .rin compararea a dou elemente din listele
de intrare se $a decide care element $a fi aduat n lista de ieire.
Exemplu:
1ir !: !" $" (" %
1ir !:)!" &" $
'ezultat: )!" !" &" $" $" (" %
Interclasare ) Implementare *n C
void adaugaSf(vector& v, int x) {
v.ev.n! = x;
v.n##;
"
void interclasare(vector v1, vector v', vector& rez) {
rez.n = 0;
int i = 0;
int . = 0;
while (i < v1.n && . < v'.n) {
if (v1.ei! <= v'.e.!) {
a%au0a1*(rez, v1.ei!);
i##;
" else {
a%au0a1*(rez, v'.e.!);
.##;
"
"
for (int 2 = i; 2 < v1.n; 2##) {
a%au0a1*(rez, v1.e2!);
"
for (int 2 = .; 2 < v'.n; 2##) {
a%au0a1*(rez, v'.e2!);
"
"
Interclasare ) Implementare *n +ascal
procedure adaua#f(var $%$ector&x%integer)&
begin
$.n%'$.n-)&
$.e+$.n,%'x&
end&
procedure interclasare($),$9%$ector&var rez%$ector)&
var i,2,@%integer&
begin
rez.n%'(&
i%')&
2%')&
-.ile (i*'$).n) and (2*'$9.n) do
i, ($).e+i,*'$9.e+2,) t.en begin
adaua#f(rez,$).e+i,)&
i%'i-)&
end
else begin
adaua#f(rez,$9.e+2,)&
2%'2-)&
end&
,or @%'i to $).n do
adaua#f(rez,$).e+@,)&
,or @%'2 to $9.n do
adaua#f(rez,$9.e+@,)&
end&
Complexitate: /(m 4 n)