Ministerul Educaţiei al Republicii Moldova

Universitatea de Stat din Moldova

Departamentul Informatică

Lucrare de laborator nr.4

La disciplina: Algoritmi,Structuri de date si

Complexitate
Tema: „Metode de acces la elementele unui masiv”

Efectuat de :
Tintaru Valeria, gr.I1801

Verificat de:
Opinca Carolina, lector universitar

1
 Chişinău, 2020
Sarcina laboratorului:

Se dă vectorul multidimensional B[-1..2][0..3][-1..2][1..3].

Implementaţi 3 metode de acces la elementele masivului.
De creat o clasă cu funcţii ce realizează accesul direct la elementele vectorului, accesul prin metoda
vectorilor Iliffe şi metoda Vectorului Definitor.

De fixat timpul de acces la elementele masivului şi de făcut comparaţie.

- Metoda directă de acces la elementele masivului.
- Metoda accelerată cu ajutorul vectorului definitoriu.
- Metoda de acces cu ajutorul vectorilor Iliffe.
Comparaţi metodele de acces după timpul de execuţie.
Comparaţi metodele de acces după memoria ocupată.

Listing-ul programului:

#include<conio.h>
#include<stdlib.h>
#include<dos.h>
#include<iostream.h>
#include<stdio.h>
#include<assert.h>

class Masiv{
protected:
int l[4],h[4];
int *V;

public:
Masiv(int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4){
int i,j,k,g;
l[0]=l1; l[1]=l2; l[2]=l3; l[3]=l4;
h[0]=h1; h[1]=h2; h[2]=h3; h[3]=h4;
int NumElem=1;
for(i=0;i<4;i++) NumElem*(h[i]-l[i]+1);
V=new int [NumElem];

FILE *f;

if((f=fopen("d:\\borlandc\\bin\\asdc4.txt","r"))==NULL)
{ cout<<"Eroare de deschidere sau fisierul nu exista!!!";
getch();
exit(0);}
else { clrscr();
cout<<"\nElementele vectorului accesului direct:\n";
int d1,d2,d3,d4,N;

2
 d1=1;
d2=(h[0]-l[0]+1)*d1;
d3=(h[1]-l[1]+1)*d2;
d4= (h[2]-l[2]+1)*d3;
int x=0, y=0;
for(int g=l[3], q=0; g<=h[3]; g++,q++){
x=6*(q+1)+7*q;
y=4;
for(int k=l[2];k<=h[2];k++){
for(int j=l[1];j<=h[1];j++){
for(int i=l[0],z=0;i<=h[0];i++,z++)
{gotoxy(x+(z+1)*3,y);
N=(i-l[0])*d1+(j-l[1])*d2+(k-l[2])*d3+(g-l[3])*d4;
fscanf(f,"%d",(V+N));
cout<<*(V+N);
}
y=y+1;
}
y=y+2;
} }
getch();
}
assert(V!=0);
fclose(f);
}
~Masiv(){
delete V;
}
int elem(int i,int j,int k,int g){
int d1,d2,d3,d4,N;
d1=1;
d2=(h[0]-l[0]+1)*d1;
d3=(h[1]-l[1]+1)*d2;
d4=(h[2]-l[2]+1)*d3;

N=(i-l[0])*d1+(j-l[1])*d2+(k-l[2])*d3+(g-l[3])*d4;
return(V[N]);
}
int elem1(int i,int j,int k,int g){
int d1,d2,d3,d4,N;
d1=1;
d2=(h[0]-l[0]+1)*d1;
d3=(h[1]-l[1]+1)*d2;
d4=(h[2]-l[2]+1)*d3;

N=(i-l[0])*d1+(j-l[1])*d2+(k-l[2])*d3+(g-l[3])*d4;
return(N);
}
};

class Vector{
protected:

3
 int *V,N;
int *P;

public:
Vector(int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4){
int i,j,k,g,d1,d2,d3,d4;

P=new int[15];
d1=1;
d2=(h1-l1+1)*d1;
d3=(h2-l2+1)*d2;
d4=(h3-l3+1)*d3;

P[0]=4;
P[1]=l1; P[2]=h1;
P[3]=l2; P[4]=h2;
P[5]=l3; P[6]=h3;
P[7]=l4; P[8]=h4;
P[9]=(h1-l1+1)*(h2-l2+1)*(h3-l3+1)*(h4-l4+1);
P[10]=d1; P[11]=d2;
P[12]=d3; P[13]=d4;
P[14]=l1*d1+l2*d2+l3*d3+l4*d4;

V=new int[P[9]];

FILE *f;
if((f=fopen("d:\\borlandc\\bin\\asdc4.txt","r"))==NULL)
{ cout<<"Eroare la deschidere sau nu exista fisierul!!";
getch();
exit(0);}
else {
clrscr();
cout<<"\nElementele vectorului definitor:\n";
int x=0,y=0;
for(int g=P[7],q=0; g<=P[8];g++,q++){
x=6*(q+1)+7*q;
y=4;
for(int k=P[5];k<=P[6];k++){
for(int j=P[3];j<=P[4];j++){
for(int i=P[1],z=0;i<=P[2];i++,z++)
{ gotoxy(x+(z+1)*3,y);
fscanf(f,"%d",(V+i*P[10]+j*P[11]+k*P[12]+g*P[13]-P[14]));
cout<<*(V+i*P[10]+j*P[11]+k*P[12]+g*P[13]-P[14]);}
y=y+1;
}
y=y+2;
}}
getch();}
assert(V!=0);
fclose(f);
}

4
~Vector(){
delete V;
delete P;}

int elem(int i,int j,int k,int g){

return(*(V+(i*P[10]+j*P[11]+k*P[12]+g*P[13]-P[14])));
}
int elem1(int i,int j,int k,int g){
return(i*P[10]+j*P[11]+k*P[12]+g*P[13]-P[14]);
}
};

class Iliffe{
protected:

int ****A;
int ***B[3];
int **B1[4],**B2[4],**B3[4];
int
*B4[3],*B5[3],*B6[3],*B7[3],*B8[3],*B9[3],*B10[3],*B11[3],*B12[3],*B13[3],*B14[3],
*B15[3],*B16[3];
int C[108];

public:
Iliffe(int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4){
int i,j,k,g;

A=B-6;
B[0]=B1+4; B[1]=B2+4; B[2]=B3+4;

B1[0]=B4+3; B1[1]=B5+3; B1[2]=B6+3; B1[3]=B7+3;

B2[0]=B8+2; B2[1]=B9+2; B2[2]=B10+2; B2[3]=B11+2;
B3[0]=B12+1; B3[1]=B13+1; B3[2]=B14+1; B3[3]=B15+1;

B4[0]=C+3; B4[1]=C+6; B4[2]=C+9;

B5[0]=C+12; B5[1]=C+15; B5[2]=C+18;
B6[0]=C+21; B6[1]=C+24; B6[2]=C+27;
B7[0]=C+30; B7[1]=C+33; B7[2]=C+36;
B8[0]=C+39; B8[1]=C+42; B8[2]=C+45;
B9[0]=C+48; B9[1]=C+51; B4[2]=C+54;
B10[0]=C+57; B10[1]=C+60; B10[2]=C+63;
B11[0]=C+66; B11[1]=C+69; B11[2]=C+72;
B12[0]=C+75; B12[1]=C+78; B12[2]=C+81;
B13[0]=C+84; B13[1]=C+87; B13[2]=C+90;
B14[0]=C+93; B14[1]=C+96; B14[2]=C+99;
B15[0]=C+102; B15[1]=C+105; B15[2]=C+108;
B16[0]=C+111; B16[1]=C+114; B16[2]=C+117;

FILE *f;
if((f=fopen("d:\\borlandc\\bin\\asdc4.txt","r"))==NULL)
{ cout<<"Eroare de deschidere sau nu exista acest fisier!!!";

5
 getch();
exit(0);}
else {
clrscr();
cout<<"\nElementele vectorului Iliffe:\n";
int x=0,y=0;
for(int g=l4,q=0;g<=h4;g++,q++){
x=6*(q+1)+7*q;
y=4;
for(int k=l3;k<=h3;k++){
for(int j=l2;j<=h2;j++){
for(int i=l1,z=0;i<=h1;i++,z++)
{gotoxy(x+(z+1)*3,y);
fscanf(f,"%2d",(*(*(*(A+g)+k)+j)+i));
cout<<*(*(*(*(A+g)+k)+j)+i);}
y=y+1;
}
y=y+2; }
}
getch();
}
assert(C!=0);
fclose(f);
}
~Iliffe(){
delete A;
delete B[3];
delete B1[4],B2[4],B3[4];
delete
B4[3],B5[3],B6[3],B7[3],B8[3],B9[3],B10[3],B11[3],B12[3],B13[3],B14[3],B15[3],B16[
3];
delete C;
}

int elem(int i,int j,int k,int g){

return(*(*(*(*(A+g)+k)+j)+i));
}
};

void main(){
clrscr();
struct time t1,t2,t3,t4,t5,t6;
int l1=-1,h1=2,l2=0,h2=3,l3=-1,h3=2,l4=1,h4=3;
Masiv m1(l1,h1,l2,h2,l3,h3,l4,h4);
Vector m2(l1,h1,l2,h2,l3,h3,l4,h4);
Iliffe m3(l1,h1,l2,h2,l3,h3,l4,h4);
//getch();

int i,j,k,g,N,N1;
double v;
cout<<"\n\n Elementul V[i,j,k,g]\n";

6
 do{ cout<<" Introduceti i [-1 .. 2] : ";
cin>>i;
}while((i>h1)||(i<l1));
do{ cout<<" Introduceti j [0 .. 3] : ";
cin>>j;
}while((j>h2)||(j<l2));
do{ cout<<" Introduceti k [-1 .. 2] : ";
cin>>k;
}while((k>h3)||(k<l3));
do{ cout<<" Introduceti g [1 .. 3] : ";
cin>>g;
}while((g>h4)||(g<l4));
//----metoda directa----

cprintf("\r\n\n * Metoda accesului direct *");

gettime(&t1);

for(v=0;v<5000000;v++)
N=m1.elem(i,j,k,g);
N1=m1.elem1(i,j,k,g);
gettime(&t2);
printf("\n Start time %2d : %2d : %2d :
%2d",t1.ti_hour,t1.ti_min,t1.ti_sec,t1.ti_hund);
printf("\n End time %2d : %2d : %2d :
%2d",t2.ti_hour,t2.ti_min,t2.ti_sec,t2.ti_hund);
int h,s;
if((t2.ti_hund-t1.ti_hund)<0){ s=t2.ti_sec-t1.ti_sec-1; h=t2.ti_hund-
t1.ti_hund+100;}

else{s=t2.ti_sec-t1.ti_sec;
h=t2.ti_hund-t1.ti_hund;}
cout<<"\r\n Timpul de acces: "<<t2.ti_min-t1.ti_min<<":"<<s<<":"<<h;
cout<<"\n Elementul ["<<i<<","<<j<<","<<k<<","<<g<<"]="<<N;
cout<<"\n Pozitia este:"<<N1;

//----metoda vectorului definitor-----

cprintf("\r\n\n * Metoda Vectorului Definitor *");

gettime(&t3);
for(v=0;v<5000000;v++)
N=m2.elem(i,j,k,g);
N1=m2.elem1(i,j,k,g);
gettime(&t4);
printf("\r\n Start time %2d : %2d : %2d :
%2d",t3.ti_hour,t3.ti_min,t3.ti_sec,t3.ti_hund);
printf("\n End time %2d : %2d : %2d :
%2d",t4.ti_hour,t4.ti_min,t4.ti_sec,t4.ti_hund);
if((t4.ti_hund-t3.ti_hund)<0){ s=t4.ti_sec-t3.ti_sec-1;
h=t4.ti_hund-t3.ti_hund+100;}
else{s=t4.ti_sec-t3.ti_sec; h4=t4.ti_hund-t3.ti_hund;}
cout<<"\n Timpul de acces: "<<t4.ti_min-t3.ti_min<<":"<<s<<":"<<h;

7
cout<<"\n Element ["<<i<<","<<j<<","<<k<<","<<g<<"]="<<N;
cout<<"\n Pozitia este:"<<N1;
//---metoda vectorului Iliffe---

cprintf("\r\n\n * Metoda Vectorului Iliffe * ");

gettime(&t5);
for(v=0;v<5000000;v++)
N=m3.elem(i,j,k,g);

gettime(&t6);
printf("\r\n Start time %2d : %2d : %2d :
%2d",t5.ti_hour,t5.ti_min,t5.ti_sec,t5.ti_hund);
printf("\n End time %2d : %2d : %2d :
%2d",t6.ti_hour,t6.ti_min,t6.ti_sec,t6.ti_hund);
if((t6.ti_hund-t5.ti_hund)<0){ s=t6.ti_sec-t5.ti_sec-1; h=t6.ti_hund-
t5.ti_hund+100;}
else{s=t6.ti_sec-t5.ti_sec; h=t6.ti_hund-t5.ti_hund;}
cout<<"\n Timpul de acces: "<<t6.ti_min-t5.ti_min<<":"<<s<<":"<<h;
cout<<"\n Element ["<<i<<","<<j<<","<<k<<","<<g<<"]="<<N<<"\n";

getch();
}

Rezultatul programului:

8
 Concluzii:

In urma lucrarii de laborator Nr.4 la Algoritmi,Structuri de date si Complexitate am avut Sarcina de a

implementa cele trei metode de acces ale unui masiv, creind un program in C++.
Astfel, am calculat timpul de acces la elementele unei matrici prin fiecare din cele trei metode.
Rezultatul aşteptat trebuia sa fie urmatorul :
- la metoda directă ar trebui sa fie cel mai mare timp de acces ,
- la metoda vectorului definitor un timp de acces mai mic,
- la metoda vectorului Iliffe cel mai mic timp de acces la elementele matricei .

Analizind metodele de acces a elementelor masivelor se poate de spus ca cea mai rapida metoda
de acces este metoda accesului cu vectorul Iliffe, mai putin rapida este metoda vectorului defenitor si
cel mai incet lucreaza metoda accesului direct, ceea ce era de asteptat. Am obtinut rezultatul dorit.
Dar din punct de vedere a economisirii spatiului cel mai efectiv este metoda accesului direct,
apoi merge metoda vectorului definitor si cel ce foloseste cel mai mult spatiu este metoda vectorului
Iliffe.
Cel mai comod de folosit este accesul cu metoda vectorului Iliffe, pentru ca lucreaza repede
ceia ce ne permite economisire de timp.