Matriz Esparcidas, ADT e Implementacion

1. ESTRUCTURA DE DATOS IESTRUCTURA DE DATOS I
ADT Matriz SparseADT Matriz Sparse
EXPOSITOR:EXPOSITOR:
Ing. Evans Balcazar VeizagaIng. Evans Balcazar Veizaga

2. En análisis numérico , una matriz dispersa es una matriz en la que la
mayoría de los elementos son cero. Por el contrario, si la mayoría de los
elementos son cero, entonces la matriz se considera densa . La fracción
de cero elementos (elementos distintos de cero) en una matriz se llama la
escasez ( densidad ).
Matrices dispersas grandes a menudo aparecen en problemas científicos la
de ingeniería de aplicaciones y en la resolución de ecuaciones diferenciales
parciales .
Cuando el almacenamiento y la manipulación de matrices dispersas en un
ordenador es beneficioso ya menudo necesario utilizar especializados
algoritmos y estructuras de datos que se aprovechan de la estructura
escasa de la matriz. Las operaciones utilizando estructuras y algoritmos
densa matriz estándar son lentos e ineficientes cuando se aplica a grandes
matrices dispersas como el procesamiento y la memoria se desperdician
en los ceros. Algunos muy grandes matrices dispersas no son factibles
para manipular utilizando algoritmos densa matriz estándar.

3. Ejemplo:
Representación usual
float M[4][4]
Se puede pensar en una ED la cual solo almacene los valores No Nulos,
tales Matrices son llamadas esparcidas.
Método para Determinar si es esparcidas: “Cuente la cantidad de
memoria que gastaría la matriz en su representación normal, llámese a ese
numero N.
Cuente la cantidad de memoria que gastaría la Matriz M en un
representación de ternas ( i, j, M[i][j]), para cada M[i][j]<>0, asígnese un
espacio de 8 bytes para cada terna (2+2+4) llámese S a ese numero.
if (N>S) then Writeln(‘Matriz Sparse’)
else Writeln(‘No Sparse’)

4. Determinar si es Esparcida ?
N= 4 x 4 = 12 x float = 48 Bytes
S = (2+2+float) x 3 = 24 Bytes
Si N>S entonces “Es Sparse”.
Determinar si es Esparcida ?
N= ?
S = ?
Si N>S ?

5. Contructor hacerSparse(Fil,Col); // Produce una matriz nula Fil x Col
setElem(f,c, elem); //Pre: si (i,j) son Validas M[i][j]=elem
getElem(f,c); //Pre: si (i,j) son Validas retorna M[i][j]
setFils(Fil);
getFils();
setCols(Col);
getCols();
Traspuesta(Sparse S); //Retorna St
void main(){
Sparse A,B;
hacerSparse(A,3,2);
getElem(A,1,2,3);
getElem(A,3,1,9);
int x=getElem(A,1,2);
B=Traspuesta(A);
}

6. Necesitaremos construir el ADT posición para poder implementar el
ADT Sparse:
struct posicion{
int fil,col;
}
hacerPosicion(f,c);
setFil(f);
getFil();
setCol(c);
getCol();
Igual();
Mayor();
Menor();

7. La estructura se mantiene ordenada en forma ascendente por POS[]
struct Sparse{
posicion POS[MAX_E];
float VALOR[MAX_E];
int n, NFil, NCol;
}
void hacerSparse(Sparse s, int Fil, int Col){
s.NFil=Fil;
s.NCol=Col;
s.n=-1;
}
setElem(f,c, elem);
getElem(f,c);
setFils(Fil);
getFils();
setCols(Col);
getCols();

8. void setElem(Sparse s, int f, int c, float elem){
if(f<1 !! f>s.NFil !! c<1 !! c>s.NCol ){
S/“Fuera de Rango”
exit(1)
}
if(s.n==-1){
if(valor!=0){
s.n++;
hacerPosicion(s.POS[s.n],f,c);
s.VALOR[s.n]=elem
}
}else{
Posicion p;
hacerPosicion(p,f,c);
int pos=0;
while(pos<=s.n && s.POS[pos]< p) //menor(s.POS[pos],p)
pos++;
….
}
}

9. if(igual(s.POS[pos],p)){ // Si es Igual la posicion
if(valor!=0){ //Modificar el VALOR pos
s.VALOR[pos]=elem;
}
else{ //ELIMINAMOS la Casilla pos
for(int k=pos; k<s.n-1; k++){
s.POS[k] = s.POS[k+1]; s.VALOR[k] =
s.VALOR[k+1];
}
s.n--;
}
}
else{ // si no es igual INSERTAMOS
if(valor!=0){
for(int k=s.n+1;k>pos+1;k- -){
s.POS[k] = s.POS[k-1]; s.VALOR[k] = s.VALOR[k-1];
}
s.POS[pos] = p; s.VALOR[pos] = elem; s.n++;
}

10. void getElem(Sparse s, int f, int c){
if(f<1 !! f>s.Nfil !! c<1 !! c>s.Ncol ){
S/“Fuera de Rango”
exit(1)
}
Posicion p;
hacerPosicion(p,f,c);
int ini=0,fin=s.n;
while(ini<fin){
int m=int((ini+fin)/2);
if(igual(s.POS[m],p))
return s.VALOR[m];
else
if(mayor(s.POS[m],p))
ini=m+1;
else
fin=m-1;
}
return 0;
}

11. INF-220 Estructura de Datos I