Código fuente de lista enlazada comprimida

Plantilla y clase ltP y gt.

Matriz de entrada booleana (P & ampt, int y){ //Matriz de entrada, entrada de formato triple.

cout & lt& ltIngrese el número de filas, columnas y elementos distintos de cero de la matriz

CIN & gt;& gtT.mu & gt& gtT.nu & gt& gtT.tu

cout & lt& lt"Envíe la posición y el valor del elemento distinto de cero:"

int k = 1;

for(;k & lt= T. tuk++)

CIN>>T.data[k]. i>& gtT.data[k]. j>& gtT.data[k]. e;

Devuelve verdadero

}

Plantilla & ltP & gt clase.

Bool OutPutSMatrix(P T){ //Matriz de salida, salida en formato estándar.

int m, n, k = 1;

for(m = 0; m & ltT.mum++){

for(n = 0; n & ltT.nun++){

if((T.data[k]).I-1)== = m & amp;& amp(T.data[k].j-1)= = n){

cout ancho(4);

cout & lt& ltT.data[k++]. e;}

De lo contrario {

cout ancho(4); cout & lt& lt"0";}

}

cout & lt& ltendl

}

Devuelve verdadero

}

// Encuentra la matriz transpuesta de la matriz

bool transpose Matrix(){

TSMatrix M, T; //Define la matriz pretranspuesta.

InPutTSMatrix(M, 0); //Matriz de entrada

int num[MAXROW+1];

int cpot[MAXROW+1]; Crea una matriz auxiliar

int q, p, t;

t . /p>

if(T.tu){

for(int col = 1; col & lt= M.nucol++)num[col]= 0;

for (t = 1; t & lt= M.tut++) ++num[M.data[t]. j];

cpot[1]= 1;

for(int I = 2;i<= M.nui++)cpot[I]= cpot[I-1] +num [I-1]; // Encuentra la posición de los elementos distintos de cero en cada columna del triplete.

for(p = 1; p & lt= M.tup++){

col=M.data[p]. j;q = cpot[col];

T.data[q]. i = colT.datos[q]. j=M.datos[p]. i;

T.datos[q]. e=M.datos[p]. e;++ cpot[col];

}

}

cout & lt& lt "La matriz transpuesta de la matriz de entrada es"

matriz de salidas(T);

Devuelve verdadero

}

Recuento booleano (RLSMatrix y ampt)

{

int num[MAXROW+1];

for(int col = 1; col & lt= T.mucol++)num[col]= 0;

for ( col = 1; col & lt= T.tucol++) ++num[T.data[col].I]

t rpos[1]= 1; for (int I = 2; i<= T.mui++)t rpos[I]= t rpos[I-1]+num[I-1] // Encuentra los elementos distintos de cero de cada fila en el triplete. Ubicación.

Devuelve verdadero

}

//Multiplica las dos matrices

bool MultSMatrix ( ){

RLSMatrix M, N, Q; //Utilice "información de enlace" para construir una matriz representada por tres triples

InPutTSMatrix(M, 1);

InPutTSMatrix(N, 1);

Contar (M); Contar (N); false

qμ= mμ; nu = n . nu; tu = 0; // Inicialización de Q

int ctemp[max fila+1];

int arow, tp, p, brow, t, q, ccol

If(M.tu*N.tu){ // Q es una matriz distinta de cero.

for(arow = 1; arow & lt= M.muarow++){

///memset(ctemp, 0, n . nu);

for(int x = 1; x & lt= N.nuX++) //Borra el acumulador para cada elemento de la fila actual.

CT EMP[x]= 0;

q . rpos[arow]= q . tu+1; //El primer elemento distinto de cero de la fila actual está en triple La posición en es +1, que representa todos los elementos distintos de cero antes de la fila.

if(a fila & lt; m mu)TP = m rpos[arow+1]

else TP = m . >for(p = m . rpos[arow]; p & ltTP; P++){ //operar en cada elemento distinto de cero de la fila actual.

brow=M.data[p]. j; // Encuentre la fila con el valor I en n y también opere en la fila con el mismo valor del elemento J.

if (navegador & ltn . mu)t = n rpos[brow+1];

else t = n tu+1; (q = n . rpos[brow]; q & ltt; Q++){ // Operar en cada elemento distinto de cero de la fila encontrada.

ccol=N.data[q]. j;

ctemp[ccol] += M.data[p]. e*N.datos[q]. e; //Coloca el valor correspondiente obtenido por multiplicación en el acumulador de elementos correspondiente.

}

}

for(ccol = 1;ccol & lt= Q.nuCcol++) //Comprime el valor encontrado en el acumulador a q medio.

if(ctemp[ccol]){

Si (++q . tu & gt; MAXSIZE) devuelve falso

Q.data[Q.tu ]. e = CT EMP[ccol];

Q.data[Q.tu]. i = flecha

Q.data[Q.tu]. j = ccol

}

}

}

matriz de salidas(Q);

Devuelve verdadero

}

Typedef struct OLNode{ //Definir elementos de lista con enlaces cruzados.

int i, j;

int e;

struct OLNode *right, * down// La tabla de filas donde se encuentra el elemento distinto de cero y los elementos siguientes de la lista.

}OLNode, * OLink

Typedef struct{ //Define la estructura del objeto de lista entrecruzada.

OLink *rhead, * chead

int mu, nu, tu; //El número de filas, columnas y elementos distintos de cero de la matriz de coeficientes

} CrossList

bool create Matrix _ OL(cross list & amp; M){ //Crear una lista con enlaces cruzados

int x, y, m

CIN & gt;& gtM.mu & gt& gtM.nu & gt& gtM.tu

If (!(m . rhead =(OLink *)malloc((m . mu+1)* sizeof(OLink)))exit(0);

If (!(m . chead =(OLink * )malloc((m . nu+1)* sizeof(OLink)))salir(0);

for(x = 0; x & lt= M.mux++)

m.rhead[x]= NULL; //Inicializa los punteros de encabezado de fila y columna, respectivamente.

for(x = 0; x & lt= M.nux++)

m . chead[x]= NULL

cout & lt& lt"Por favor; Ingrese la matriz en formato triplete: "

for(int I = 1; I& lt= M.tui++){

CIN & gt; & gtx & gt& gty & gt& gtm; //Ingrese elementos distintos de cero en cualquier orden (en forma de triples ordinarios)

OLink p, q;

If (!(p = (OLink) malloc(sizeof( ol node)))exit(0); //Crea un nuevo nodo para almacenar el nuevo elemento de la entrada

p->; >;e = m;

if(m . rhead[x]= = NULL | | m . rhead[x]-& gt;j & gty){

p- >; derecha = m . rhead[x]; m . rhead[x] = p;

}

De lo contrario {

for(q = m . rhead[x]; (Q->RIGHT)&&(Q->RIGHT->j<y); q = q->RIGHT //Encuentra el nodo en la posición de inserción de la tabla de filas

p->right = q->right; q->right=p; //Inserción completa de fila

}

if(m . chead[y]= = NULL | | m .chead[y]->i>x){

p->abajo = m.chead[y];m chead[y]= p;

}<. /p>

En caso contrario{

for(q = m. chead[y];(Q->abajo)& &(q->abajo->i<x); q = q-> ;down); //Encuentra la posición de inserción del nodo en la lista

p-> ;down ​​​​= q->down;q->;down ​​​​= p;//Completo inserción de columna

}

}

Devuelve verdadero

}

booloutputs matriz _ ol(lista cruzada t ){// Genera la lista de enlaces cruzados en forma de una matriz normal

for(int I = 1. ; i & lt= T.mui++){

OLink p = t rhead[I];

for(int j = 1; j & lt= T.nuj++){

if ((p)& amp;& amp(j = = p->j)){

cout & lt& ltsetw(3)& lt;& ltp- >;e;p = p->right;

}

Otro

cout & lt& ltsetw(3)& lt;& lt"0 ";

}

cout & lt& ltendl

}

Devuelve verdadero

}

//Adición de matriz

bool AddSMatrix(){

CrossList M, N; //Crea dos objetos de lista entrecruzados e inicialízalos.

crear matriz _ OL(M);

crear matriz _ OL(N

cout & lt& lt"La matriz suma de las dos matrices de entrada; es :"

OLink pa, pb, pre, HL[max row+1]; //Defina punteros auxiliares, donde pa y pb son M, N es el elemento actualmente comparado y pre es el predecesor elemento de pa .

for(int x = 1; x & lt= M.nux++)HL[x]= m . chead[x];

for(int k = 1; k & . lt= M.muK++){ //Realizar operaciones en cada fila de m.

pa = m . rhead[k]; Pb = n . rhead[k]; pre = NULL

Y (pb){ // Elimina cada fila en n Elemento,

OLink p;

if (!(p =(OLink)malloc(sizeof(ol node)))exit(0); //Abre un nuevo nodo, almacena el elemento sacado de n.

p->; j;

if(NULL == pa | | pa-& gt; j & gtpb- >J){ //Cuando M termina de verificar esta línea o pb debe colocarse delante de pa

rhead[p-& gt;I]= p;

Otro

pre->;right = p;

p->; right = papre = p

if(NULL = = m.chead[p->J]){ //Inserción de columna

M.chead[p->j]= p;p->;down ​​​​= NULL

}

En caso contrario{

p ->down = HL[p->j]->down;HL[p->j]->down ​​​​= p;

}

HL[p->j]= p;

Pb = p B->right;

}

Otro

if((NULL!= pa)&&pa->j<pb->J){ //Si el elemento pb en este momento debe colocarse después pa, luego compárelo con pa más tarde

pre = papa = pa-& gt

}

Otro

if (pa-& gt; j = = p B->J){ //Si pa y pb están en la misma posición, suma los valores

pa->e+= p B ->e;

p>

If (!pa->E){ //Si la suma es 0, elimina el nodo y cambia el valor correspondiente del elemento predecesor en la fila y columna.

If(NULL==pre) //Modifica el valor del elemento predecesor de la fila.

rhead[pa->I]=pa->right;

Otro

pre->;right = pa-> /p>

p = papá = pa-& gt; Correcto;

if(m . chead[p-& gt;j]= = p)m chead[p- >j . ]= HL[p->j]= p->Down;//Modificar el valor del elemento predecesor de la columna

Otros

HL[p ->j] ->abajo = p->abajo;

free(p); Pb = p B->right;

}

En caso contrario {

pa = pa-& gt; Pb = p B- & gt; }

}

matriz de salidas _ OL(M);

devuelve verdadero

}

int main (){

cout . fill(' * ');

cout & lt& ltsetw(80)& lt;& lt'*'; .fill("");

//system(" color 0C ");

cout & lt& ltsetw(50)& lt;& lt"* * *Bienvenido al programa de operación matricial* * *"

cout . fill(' * ');

cout & lt& ltsetw(80)& lt;& lt '*';

cout . fill("");

cout & lt& lt"Seleccione la operación a realizar:"

cout & lt& lt " 1: Transposición de matriz. "& lt& ltendl

cout & lt& lt"2. Método de suma (resta) de matrices."& lt& ltendl

cout & lt& lt" 3: Multiplicación de matrices."& lt& ltendl

cout & lt& lt"4: Salir del programa. "& lt& ltendl

char c = getchar();

if(c=='1 ' )

transponer matriz(); //Llamar a la función de transposición de matriz

Otros

if(c=='2 ')

adds Matrix(); //Llamar a la función de suma de matrices

Otros

if(c=='3 ')

mults Matrix(); Llamar a la función de multiplicación de matrices

Otros

Salir (0); //Salir

Devuelve 0;

}