http://www.youtube.com/watch?

v=W62an6HrSww
// ESPARSA
#include<iostream.h>
#include<funciones.h>
float matrix[10][12];
class nodo
{
public:
nodo(int f,int c,nodoarbol *narbol,nodo *sf,nodo *sc)
{
valor=narbol;
fila=f;
columna=c;
sfila=sf;
scolumna=sc;
}
int fila,columna;
nodoarbol *valor;
nodo *sfila,*scolumna;
friend class esparsa;
};
typedef nodo *pnodo;
typedef nodoarbol *anodo;
class esparsa
{
public:
esparsa(int f,int c)
{
head=new nodo(0,0,NULL,NULL,NULL);
filas=f;columnas=c;
}
void insertar(int f,int c,char *expresion);
void borrar(int f,int c);
float evaluar(int f,int c);
void generarmatriz(int f,int c);
//cambiarla por la funcion generar matriz
pnodo buscar(int f,int c);
float procesararbol(anodo nod);
//necesariamente tiene q estar aca
private:
pnodo head;
int filas,columnas;
pnodo buscarpos(int v, pnodo nod, int band);
void borrarfc(pnodo nod);
void reducir(int v);
};
void esparsa::insertar(int f,int c,char *expresion)//inserta un elemento en la coordenadas
f,c, si ya existe modifica su valor con el nuevo valor introducido
{

pnodo nuevo,auxf,auxc,temp;
anodo auxa,auxb;
//puntero tipo
nodo arbol a la raiz del arbol de expresiones
auxa=generararbol(expresion);
temp=buscar(f,c);
if(temp!=NULL)
{
auxb=temp->valor;
temp->valor=auxa;
//si existe el nodo le
cambio de arbol de expresiones
borrararbol(auxb);
//y libero la memoria
utilizada por el arbol anterior
}
else
{
nuevo=new nodo(f,c,auxa,NULL,NULL);//si no existe crea un nodo con
el arbol de expresiones
auxc=buscarpos(c,head,0);
auxf=buscarpos(f,head,1);
temp=auxc;
if(auxc->sfila==NULL||auxc->sfila->fila>f)
{
nuevo->sfila=auxc->sfila;
auxc->sfila=nuevo;
}
else
{
while(temp->sfila!=NULL&&temp->sfila->fila<f)
temp=temp->sfila;
nuevo->sfila=temp->sfila;
temp->sfila=nuevo;
}
if(auxf->scolumna==NULL||auxf->scolumna->columna>c)
{
nuevo->scolumna=auxf->scolumna;
auxf->scolumna=nuevo;
}
else
{
temp=auxf;
while(temp->scolumna!=NULL&&temp->scolumna>columna<c)
temp=temp->scolumna;
nuevo->scolumna=temp->scolumna;
temp->scolumna=nuevo;
}
}
}
void esparsa::borrar(int f,int c)//borra el elemento q esta en las coordenadas f,c , si no
existe el elemento retorna

{
pnodo aux,auxf,auxc,temp;
anodo auxa;
aux=buscar(f,c);
if(aux==NULL)
{
cout<<" la celda no contiene ninguna informacion"<<endl;
return;
}
auxc=buscarpos(c,head,2);
if(auxc==head) return;
auxf=head->sfila;
while(auxf->fila!=f)
auxf=auxf->sfila;
temp=auxc;
while(temp->sfila!=NULL&&temp->sfila->fila!=f)
temp=temp->sfila;
aux=temp->sfila;
auxc=aux->scolumna;
temp->sfila=aux->sfila;
temp=auxf;
while(temp->scolumna!=aux)
temp=temp->scolumna;
temp->scolumna=auxc;
auxa=aux->valor;
//
borrararbol(auxa);
//borramos el arbol de expresiones ->
investigar sobre destructor de arbol bianrio
delete aux;
//luego borramos la celda
reducir(0);
reducir(1);
}
float esparsa::evaluar(int f,int c)
{
pnodo aux;
aux=buscar(f,c);
if(aux==NULL)
return 0.00005;
else
return procesararbol(aux->valor);//evalua el arbol q cuelga de la matriz
}
float esparsa::procesararbol(anodo nod)
{
int c=nod->band;
switch(c)
{
case 0: return nod->var;break;
case 1:
{
float a=procesararbol(nod->izq);
float b=procesararbol(nod->der);

if(a<=0.00005&&a>=0.000049||b<=0.00005&&b>=0.000049)
return (float)0.00005;
switch(nod->operador)
{
case '+':return a+b;break;
case '-':return a-b;break;
case '*':return a*b;break;
case '/':
{
if(b==0)
return 0.00005;
return a/b;
break;
}
}
}
case 2:
{
int f=nod->posicion[0];
int c=nod->posicion[1];
return evaluar(f,c);
}
}
}
void esparsa::generarmatriz(int f,int c)
{
int cuadrante=evaluar(f,c);
pnodo auxf,auxc;
switch(cuadrante)
{
case 0:f=1;c=1;break;
case 1:f=1;c=87;break;
case 2:f=42;c=1;break;
case 3:f=42;c=87;break;
default:f=f-5;c=c-6;
}
auxf=head->sfila;
while(auxf!=NULL&&auxf->fila<=f)
auxf=auxf->sfila;
for(int i=0;i<10;i++)
{
if(auxf!=NULL&&auxf->fila==i+1)
{
auxc=auxf->scolumna;
while(auxc!=NULL&&auxc->columna<=c)
auxc=auxc->scolumna;
for(int j=0;j<12;j++)
{
if(auxc!=NULL&&auxc->columna==j+1)
matrix[i][j]=evaluar(i+1,j+1);

else if(auxc!=NULL)
{
matrix[i][j]=-0.00005;
auxc=auxc->scolumna;
}
else
matrix[i][j]=-0.00005;
}
}
else if(auxf!=NULL)
auxf=auxf->sfila;
}
}
pnodo esparsa::buscarpos(int v,pnodo nod,int band)//para insertar necesitamos saber en
q fila y columna hacerlo
{
//retorna un puntero a la fila o columna deseada, si no
existe
pnodo aux,nuevo;
//crea el nodo q se necesite
if(band==0)
{
aux=nod;
while(aux->scolumna!=NULL&&aux->scolumna->columna<v)
aux=aux->scolumna;
if(aux->scolumna!=NULL&&aux->scolumna->columna==v)
return aux->scolumna;
nuevo=new nodo(0,v,0,NULL,NULL);
nuevo->scolumna=aux->scolumna;
aux->scolumna=nuevo;
return nuevo;
}
else if(band==1)
{
aux=nod;
while(aux->sfila!=NULL&&aux->sfila->fila<v)
aux=aux->sfila;
if(aux->sfila!=NULL&&aux->sfila->fila==v)
return aux->sfila;
nuevo=new nodo(v,0,0,NULL,NULL);
nuevo->sfila=aux->sfila;
aux->sfila=nuevo;
return nuevo;
}
else
{
aux=nod;
while(aux->scolumna!=NULL&&aux->scolumna->columna<=v)
aux=aux->scolumna;
if(aux->columna==v)
return aux;
else

return nod;
}
}
void esparsa::reducir(int v)//despues de eliminar puede que nos queden filas o columnas
vacias, se encarga de eliminarlas
{
pnodo aux,temp=head;
if(v==0)
aux=head->sfila;
else
aux=head->scolumna;
while(aux!=NULL)
{
if(v==0&&aux->scolumna==NULL)
{
temp->sfila=aux->sfila;
delete aux;
aux=temp->sfila;
}
else if(v==0)
{
aux=aux->sfila;
temp=temp->sfila;
}
else if(v==1&&aux->sfila==NULL)
{
temp->scolumna=aux->scolumna;
delete aux;
aux=temp->scolumna;
}
else
{
aux=aux->scolumna;
temp=temp->scolumna;
}
}
}
pnodo esparsa::buscar(int f,int c)//retorna el nodo si lo encuentra dentro de la matriz, si
no retorna null
{
pnodo aux;
aux=buscarpos(c,head,2);
if(aux==head)
return NULL;
while(aux->sfila!=NULL&&aux->sfila->fila<=f)
aux=aux->sfila;
if(aux->fila==f)
return aux;
else

return NULL;
}

///

FUNCIONES

#include<iostream.h>
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include<pila.h>
#include<ctype.h>
typedef nodoarbol *pnodoarbol;
int evaluare(char a)
{
int b=isalpha(a);
if(b!=0)
return 2;
int c=isdigit(a);
if(c!=0)
return 0;
return 1;
};
int evaluarf(char *celda)
{
int ant=0,i=0,valor=0;
while(isalpha(celda[i]))
{
valor=int(celda[i])-64;
valor=valor+ant;
ant+=26;
i++;
}
return valor;
};
int evaluarc(char *celda)
{
int ant=0,valor,i=0;
while(isalpha(celda[i]))
i++;
while(isdigit(celda[i]))
{
valor=int(celda[i])-48;
valor=valor+ant;
ant=valor*10;
i++;
}
return valor;
};

pnodoarbol generararbol(char *expresion)

{
char temp[80];
pila Pila;
int i=0,j,band;
int pos[2]={0,0};
pnodoarbol auxd,auxi,nuevo;
while(expresion[i]!='\000')
{
j=0;
while(expresion[i]!=' ')
{
temp[j]=expresion[i];
i++;
j++;
}
temp[j]='\000';
band = evaluare(temp[0]);
switch(band)
{
case 0:
{
nuevo=new nodoarbol(atof(temp),' ',pos,0,NULL,NULL);
Pila.push(nuevo);
break;
}
case 1:
{
nuevo=new nodoarbol(0,temp[0],pos,1,NULL,NULL);
auxd=Pila.pop();
auxi=Pila.pop();
nuevo->izq=auxi;
nuevo->der=auxd;
Pila.push(nuevo);
break;
}
case 2:
{
pos[0]=evaluarf(temp);
pos[1]=evaluarc(temp);
nuevo=new nodoarbol(0,' ',pos,2,NULL,NULL);
Pila.push(nuevo);
break;
}
}
i++;
}
return Pila.pop();
};
void borrararbol(pnodoarbol nodo)//investigar eldestructor de un arbol binario.

{
if(nodo!=NULL)
{
borrararbol(nodo->izq);
borrararbol(nodo->der);
delete nodo;
}
};
int evaluarcuadrante(int f,int c)
{
if(f<=10)
{
if(c<=12)
return 0;
if(c>=87)
return 1;
return 4;
}
else if(f>=42)
{
if(c<=12)
return 2;
if(c>=87)
return 3;
return 4;
}
else
return 4;
};
//-----Declaracin de funciones// funcion infijo a posfijo
//-----Variables globales
char Simb[4][2]={{'(',')'},{'-','+'},{'/','*'},{'$','\0'}},
expr[50], pila[50], expr_c[50], epre[50], epos[50],
elem, simb;
int i, j, n, tope, val, cont1, cont2, v;
//-----Limpia la variable */
void limpiar(char a[], int n){
for(i=0;i<n;i++){
a[i]='\0';
}
};
//-----Cuenta cuantos caracteres hay en la variable
int tama(char var[]){
for(n=0;var[n]!='\0';++n);
return(n);
};
//-----Pasa de una variable a otra
void pasar(char a[], char b[]){

int n1, n2;

n1=tama(a);
n2=tama(b);
if(n1>n2){
for(i=0;i<n1;i++){
a[i]=b[i];
}
}
if(n1<n2){
for(i=0;i<n2;i++){
a[i]=b[i];
}
}
};
//-----Verifica si no le faltan parntesis a la funcin
int verif(char ex[]){
val=0;
n=tama(ex);
if(n>0){
tope=0;
cont1=cont2=0;
for(i=0;i<n;i++){
elem=ex[i];
if(elem=='('){
pila[tope]=elem;
tope+=1;
pila[tope]='\0';
}
else{
if(elem==')'){
if(tope>0){
if(pila[tope-1]=='('){
tope-=1;
pila[tope]='\0';
}
}
else{
pila[tope]=elem;
tope+=1;
pila[tope]='\0';
}
}
}
}
if(tope>0){
for(i=0;i<tope;i++){
if(pila[i]=='('){
cont1+=1;
}

if(pila[i]==')'){
cont2+=1;
}
}
if(cont1<cont2){
val=2;
}
if(cont1>cont2){
val=1;
}
}
else{
val=3;
}
}
else{
val=0;
}
return(val);
};
//-----Recorre los caracteres un lugar
void rec_exp(char a[]){
int x=tama(a);
for(i=0;i<(x-1);i++){
a[i]=a[i+1];
}
a[i]='\0';
};
//-----Verifica si es un operador
int sim(char s){
v=0;
for(i=0;i<4;i++){
for(j=0;j<2;j++){
if(s==Simb[i][j]){
v=1;
}
}
}
return(v);
};
//-----Verifica la prioridad para colocar en la pila // A3=A1 +A2 *4 +6
int prio(char s1, char s2){
int p1, p2;
p1=p2=0;
for(i=0;i<4;i++){
for(j=0;j<2;j++){
if(s1==Simb[i][j]){

p1=i;
}
if(s2==Simb[i][j]){
p2=i;
}
}
}
if(p1<p2){
i=-1;
}
else{
if(p1==p2){
i=0;
}
else{
i=1;
}
}
return(i);
};

//-----Conversin de la funcin a postfija

void conv_pos(char ex[], char epos[]){
tope=-1;
n=tama(ex);
while(ex[0]!='\0'){
simb=ex[0];
rec_exp(ex);
n-=1;
if(simb=='('){
tope+=1;
pila[tope]=simb;
}
else{
if(simb==')'){
while(pila[tope]!='('){
int x=tama(epos);
epos[x]=pila[tope];
pila[tope]='\0';
tope-=1;
}
pila[tope]='\0';
tope-=1;
}
else{
if(sim(simb)==0){
int x=tama(epos);
epos[x]=simb;

}
else{
if(tama(pila)>0){
while(prio(simb,pila[tope])<=0){
int x=tama(epos);
epos[x]=pila[tope];
pila[tope]='\0';
tope-=1;
if(tope<0){
break;
}
}
}
tope+=1;
pila[tope]=simb;
}
}
}
}
while(tope>=0){
int x=tama(epos);
epos[x]=pila[tope];
pila[tope]='\0';
tope-=1;
}
};
void ajustarexpr(char epos[])
{
int j=0;
for(int i=0;epos[i]!='\0';i++,j++)
{
if(epos[i]=='+'||epos[i]=='*'||epos[i]=='-'||epos[i]=='/')
{
expr_c[j]=epos[i];
expr_c[j+1]=' ';
j++;
}
else
expr_c[j]=epos[i];
}
expr_c[j]='\000';
};
//

NODOARBOL

#include<iostream.h>
class nodoarbol

{
public:
nodoarbol(float v,char op,int pos[2],int b,nodoarbol *i,nodoarbol *d)
{
var=v;
operador=op;
posicion[0]=pos[0];
posicion[1]=pos[1];
band=b;
izq=i;
der=d;
}
float var;
int posicion[2],band;
char operador;
nodoarbol *izq,*der;
};
//

PILA

#include<iostream.h>
#include<nodoarbol.h>
typedef nodoarbol *anodo;
class nodo2
{
public:
nodo2(anodo v,nodo2 *sig=NULL)
{
valor=v;
siguiente=sig;
}
anodo valor;
nodo2 *siguiente;
friend class pila;
};
class pila
{
public:
pila(){ultimo=NULL;}
void push(anodo v);
anodo pop();
private:
nodo2 *ultimo;
};
void pila::push(anodo v)

{
nodo2 *nuevo;
nuevo=new nodo2(v,ultimo);
ultimo=nuevo;
}
anodo pila::pop()
{
nodo2 *nodo;
anodo v;
if(!ultimo) return NULL;
nodo=ultimo;
ultimo=nodo->siguiente;
v=nodo->valor;
delete nodo;
return v;
}
//
EXCEL

#include<iostream.h>
#include <stdio.h>
#include <conio.h>
#include<stdlib.h>
#include<esparsa.h>
void main()
{
esparsa Esparsa(52,99);//topes maximos en filas y columnas d ela hoja de
calculo
for(int i=0;i<10;i++)
{
for(int j=0;j<12;j++)
matrix[i][j]=-0.00005;
}
//mostrar(1,1,matrix);//
char celda[5];
int band=1;
int f,c,n;
do{
i=0;
for(;(expr[i]=getchar())!='\n';i++); //estoy desperdiciando mucha
memoria
{
if(expr[i]=='\n')
expr[i]='\0';
}
i=0;
for(;i<5&&expr[i]!='='&&expr[i]!=' '&&expr[i]!='\0';i++)
celda[i]=expr[i];

celda[i]='\0';
switch(expr[i])
{
case '=':
{
f=evaluarf(celda);
c=evaluarc(celda);
i++;
for(int j=0;expr[i]!='\0';j++,i++)
expr_c[j]=expr[i];
conv_pos(expr_c,epos);
ajustarexpr(epos);
Esparsa.insertar(f,c,expr_c);
break;
}
case ' ':
{
f=evaluarf(celda);
c=evaluarc(celda);
Esparsa.borrar(f,c);
break;
}
case '\0':
{
f=evaluarf(celda);
c=evaluarc(celda);
float respuesta=Esparsa.evaluar(f,c);
if(respuesta<=0.00005&&respuesta>=0.000049)
cout<<celda<<" celda vacia o falta informacion
para procesar"<<endl;
else
cout<<"El valor de "<<celda<<" es:
"<<respuesta<<endl;
break;
}
default:
band=0;
}
Esparsa.generarmatriz(f,c);
n=tama(expr_c);
//cout<<expr_c;
limpiar(expr_c,n);
/*int g=evaluarcuadrante(f,c);// evaluar la posicion de la impresion de las filas
y columnas
switch(g)
{
case 0: mostrar(1,1,matrix);break; //vamos phoco
case 1: mostrar(1,87,matrix);break;
case 2: mostrar(42,1,matrix);break;
case 3: mostrar(42,87,matrix);break;

default: mostrar(f-5,c-6,matrix);
}*/
}while(band==1);
}