稀疏矩陣的運算

import java.util.*;

創(chuàng)新互聯(lián)建站企業(yè)建站,十多年網(wǎng)站建設經(jīng)驗，專注于網(wǎng)站建設技術，精于網(wǎng)頁設計，有多年建站和網(wǎng)站代運營經(jīng)驗，設計師為客戶打造網(wǎng)絡企業(yè)風格，提供周到的建站售前咨詢和貼心的售后服務。對于成都網(wǎng)站建設、網(wǎng)站制作中不同領域進行深入了解和探索，創(chuàng)新互聯(lián)在網(wǎng)站建設中充分了解客戶行業(yè)的需求，以靈動的思維在網(wǎng)頁中充分展現(xiàn)，通過對客戶行業(yè)精準市場調(diào)研，為客戶提供的解決方案。

//稀疏矩陣算法。

//稀疏矩陣算法是為了在大型矩陣中非零元素少時，減少存貯空間，并提高矩陣運算速度的。

//但本例中的矩陣只是為了演示算法，都比較小，時間和空間效率提升可以忽略。

public class SparseMatrix{

public static void main(String[] args){

TripleSMatrix tsm=new TripleSMatrix(7,4);

//tsm.printTriple();

tsm.printMatrix();

TripleSMatrix tsm2=new TripleSMatrix(7,4);

System.out.println("矩陣a:");

tsm.printMatrix();

System.out.println("矩陣b:");

tsm2.printMatrix();

int[][] matrixSum=addSMatrix(tsm,tsm2);

System.out.println("矩陣a+矩陣b:");

for(int i=0;i matrixSum.length;i++){

for(int j=0;j matrixSum[i].length;j++){

System.out.print(" "+matrixSum[i][j]);

}

System.out.println("");

}

}

public static int[][] addSMatrix(TripleSMatrix t1,TripleSMatrix t2){ //計算兩個三元組表示的矩陣之和，返回結束數(shù)組

if(t1.rows!=t2.rows||t1.columns!=t2.columns){

System.out.println("這兩個矩陣不能相加");

return null;

}

int[][] c=new int[t1.rows][t2.columns];

int i=1,j=1;

while(i =t1.nonzeroElements||j =t2.nonzeroElements){

if(t1.triple[i][0] t2.triple[j][0]i =t1.nonzeroElements){

c[t1.triple[i][0]-1][t1.triple[i][1]-1]=t1.triple[i][2];

i++;

}else if(t2.triple[j][0] t1.triple[i][0]j =t2.nonzeroElements){

c[t2.triple[j][0]-1][t2.triple[j][1]-1]=t2.triple[j][2];

j++;

}else{

if(t1.triple[i][1] t2.triple[j][1]i =t1.nonzeroElements){

c[t1.triple[i][0]-1][t1.triple[i][1]-1]=t1.triple[i][2];

i++;

}else if(t1.triple[i][1]t2.triple[j][1]j =t2.nonzeroElements){

c[t2.triple[j][0]-1][t2.triple[j][1]-1]=t2.triple[j][2];

j++;

}else{

c[t1.triple[i][0]-1][t1.triple[i][1]-1]=t1.triple[i][2]+t2.triple[j][2];

i++;j++;

}

}

}

return c;

}

}

//下面的類定義不一定是最好的，比如其中的屬性大多是包訪問權限，可以改進。

class TripleSMatrix{ //定義了一個三元組的類。

int[][] triple=new int[2001][3]; //三元組數(shù)組，假設稀疏矩陣的值都是整數(shù)。最多可以有2000個非零元素。第零行沒有用。

int rows,columns,nonzeroElements; //稀疏矩陣的行列數(shù)和非零元素個數(shù)。

TripleSMatrix(int rows,int columns){ //構造方法，rows是稀疏矩陣的行數(shù)，columns是稀疏矩陣的列數(shù)。

Scanner input=new Scanner(System.in);

System.out.println("請輸入稀疏矩陣三元組");

System.out.println("以行 列 值的形式輸入，如：1 2 4表示第1行第2列元素的值為4，當輸入的行為999時結束：");

int count=1;

int i=0,j,v; //i行j列,值v

while(i!=999input.hasNext()){

i=input.nextInt();

j=input.nextInt();

v=input.nextInt();

if(irows||i 1||jcolumns||j 1){

System.out.println("剛才的行，列值錯，將被忽略");

continue;

}

triple[count][0]=i;

triple[count][1]=j;

triple[count][2]=v;

count++;

}

this.rows=rows;

this.columns=columns;

this.nonzeroElements=count-1;

sortTriple(triple,1,count); //對輸入的三元組排序。

}

static void sortTriple(int[][] triple,int first,int end){ //對三元組排序方法，按行排，行一樣按列排。

Arrays.sort(triple,first,end,new Comparator int[](){

public int compare(int[] t1,int[] t2){

if(t1[0]t2[0]) return 1;

if(t1[0] t2[0]) return -1;

if(t1[0]==t2[0]) return t1[1]-t2[1];

return 0; //沒有用的一個語句，但沒有它編譯通不過。

}

});

}

public void printMatrix(){ //打印出當前三元組表示的稀疏矩陣。

int row=1,column=1; //row當前要打印的行，column當前要打印的列。

for(int t=1;t =nonzeroElements;t++){

while(triple[t][0]row){ //三元組中的行比當前行大

if(column!=1){ //前面打印的行沒有打印完，繼續(xù)打印完

for(;column =columns;column++) System.out.print(" "+0);

column=1; //新的一行列從1開始。

}else{ //當前行全為0

for(int i=1;i =columns;i++){

System.out.print(" "+0);

}

}

System.out.println(""); //換行

row++; //下一行

}

for(;column triple[t][1];column++){ //當前打印的列小于三元組中的列，前面要補零。

System.out.print(" "+0);

}

System.out.print(" ".substring(0,6-(String.valueOf(triple[t][2])).length())+triple[t][2]); //打印三元組對應的元素。

column++;

}

if(column!=1){ //前面打印的行沒有打印完，繼續(xù)打印完

for(;column =columns;column++) System.out.print(" "+0);

System.out.println("");

column=1;

row++ ;

}

for(;row =rows;row++){ //三元組中沒有對應的值了，矩陣后面的元素全為0

for(column=1;column =columns;column++){

System.out.print(" "+0);

}

System.out.println("");

}

}

public void printTriple(){ //打印三元組

for(int i=1;i =nonzeroElements;i++){

for(int j=0;j 3;j++){

System.out.print(triple[i][j]+" ");

}

System.out.println("");

}

}

}

各位高手,求稀疏矩陣的運算的代碼.

★稀疏矩陣運算器源代碼：

#include stdio.h

#define MAXSIZE 1000

#define MAXRC 100

typedef struct

{

int i,j;

int e;

}Triple;

typedef struct

{

Triple data[MAXSIZE+1];

int rpos[MAXRC+1];//存放各行第一個非零元在存儲數(shù)組中的位置，若該行無非零元，則其rpos[]值為零

int mu,nu,tu;

}RLSMatrix;

ScanRLSMatrix(RLSMatrix *T)

{//矩陣輸入函數(shù)，輸入各行非零元及其在矩陣中的行列數(shù)

int k;

printf(" ***********************************************************\n");

printf(" 請輸入矩陣的行數(shù)，列數(shù)，非零元素個數(shù) \n");

printf(" ");

scanf("%d,%d,%d",(*T).mu,(*T).nu,(*T).tu);

if((*T).tuMAXSIZE){printf("非零個數(shù)超出定義范圍！");exit(0);}

for(k=1;k=(*T).tu;k++){

printf(" 按行存儲請輸入第%d個非零元素的行數(shù),列數(shù),其值:",k);

scanf("%d,%d,%d",(*T).data[k].i,(*T).data[k].j,(*T).data[k].e);

if(!(*T).data[k].i||!(*T).data[k].j||(*T).data[k].i(*T).mu||(*T).data[k].j(*T).nu){

printf("輸入有誤！");

exit(0);

}

}

printf(" ************************************************************\n");

//計算各行第一個非零元素在存儲數(shù)組中的位置

//若該行無非零元，則rpos[]值為零

int num[(*T).mu+1],row,cpot[(*T).mu+1];

cpot[1]=1;

for(k=1;k=(*T).mu;k++)

num[k]=0;

for(k=1;k=(*T).tu;k++)

++num[(*T).data[k].i];

for(row=2;row=(*T).mu;row++)

cpot[row]=cpot[row-1]+num[row-1];

for(row=1;row=(*T).mu;row++){

if(cpot[row]=(*T).tu)

if((*T).data[cpot[row]].i==row){

(*T).rpos[row]=cpot[row];

}

else

(*T).rpos[row]=0;

else

(*T).rpos[row]=0;

}

}

PrintRLSMatrix(RLSMatrix T)

{//矩陣輸出函數(shù)，輸出矩陣形式

int a,b,m=0;

printf(" -----------------------------------------\n");

for(a=1;a=(T).mu;a++){printf(" ");

for(b=1;b=(T).nu;b++){

if((T).rpos[a]a==(T).data[(T).rpos[a]].ib==(T).data[(T).rpos[a]].j){

//(T).rpos[a]不為零時，輸出該行的非零元

printf("%4d",(T).data[(T).rpos[a]].e);

(T).rpos[a]++;

}

else

{

printf("%4d",m);}

}

printf("\n");

}

printf(" ----------------------------------------\n");

}

FasttransposeRLSMatrix(RLSMatrix M,RLSMatrix *Q)

{//矩陣快速轉置

int col,t,p,q,num[M.nu],cpot[M.nu];

(*Q).mu=M.nu;(*Q).nu=M.mu;(*Q).tu=M.tu;

if((*Q).tu){

for(col=1;col=M.nu;++col)num[col]=0;

for(t=1;t=M.tu;++t)++num[M.data[t].j];//求M中每一行含非零元素的個數(shù)

cpot[1]=1;

//求第col列中第一個非零元在(*Q).data中的序號

for(col=2;col=M.nu;++col)cpot[col]=cpot[col-1]+num[col-1];

for(p=1;p=M.tu;++p){

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

(*Q).data[q].i=M.data[p].j;

(*Q).data[q].j=M.data[p].i;

(*Q).data[q].e=M.data[p].e;

++cpot[col];

}

}

//計算各行第一個非零元素在存儲數(shù)組中的位置

//若該行無非零元，則rpos[]值為零

int Num[(*Q).mu+1],row,Cpot[(*Q).mu+1],k;

Cpot[1]=1;

for(k=1;k=(*Q).mu;k++)

Num[k]=0;

for(k=1;k=(*Q).tu;k++)

++Num[(*Q).data[k].i];

for(row=2;row=(*Q).mu;row++)

Cpot[row]=Cpot[row-1]+Num[row-1];

for(row=1;row=(*Q).mu;row++){

if(Cpot[row]=(*Q).tu)

if((*Q).data[Cpot[row]].i==row){

(*Q).rpos[row]=Cpot[row];

}

else

(*Q).rpos[row]=0;

else

(*Q).rpos[row]=0;

}

return 1;

}

HeRLSMatrix(RLSMatrix *M,RLSMatrix *N,RLSMatrix *Q)

{//矩陣求和函數(shù)

if((*M).mu!=(*N).mu||(*M).nu!=(*N).nu)

{printf("不滿足矩陣相加的條件!");return 0;}

int k=1;

Triple *p,*q;

//設置兩個指針，分別指向M，N的第一個非零元位置，移動指針進行比較，得出相加后的新矩陣非零元

p=(*M).data[1];

q=(*N).data[1];

while(p(*M).data+(*M).tu+1q(*N).data+(*N).tu+1)

if((*p).i=(*q).i)

if((*p).i(*q).i){

(*Q).data[k].i=(*p).i;

(*Q).data[k].j=(*p).j;

(*Q).data[k].e=(*p).e;

k++;p++;

}

else

if((*p).j=(*q).j)

if((*p).j(*q).j){

(*Q).data[k].i=(*p).i;

(*Q).data[k].j=(*p).j;

(*Q).data[k].e=(*p).e;

k++;p++;

}

else

{

(*Q).data[k].i=(*p).i;

(*Q).data[k].j=(*p).j;

(*Q).data[k].e=(*p).e+(*q).e;

k++;p++;q++;

}

else {

(*Q).data[k].i=(*q).i;

(*Q).data[k].j=(*q).j;

(*Q).data[k].e=(*q).e;

k++;q++;

}

else

{

(*Q).data[k].i=(*q).i;

(*Q).data[k].j=(*q).j;

(*Q).data[k].e=(*q).e;

k++;q++;

}

if(p=(*M).data+(*M).tu)

while(p=(*M).data+(*M).tu){

(*Q).data[k].i=(*p).i;

(*Q).data[k].j=(*p).j;

(*Q).data[k].e=(*p).e;

k++;p++;

}

if(q=(*N).data+(*N).tu)

while(q=(*N).data+(*N).tu){

(*Q).data[k].i=(*q).i;

(*Q).data[k].j=(*q).j;

(*Q).data[k].e=(*q).e;

k++;q++;

}

(*Q).mu=(*M).mu;(*Q).nu=(*M).nu;(*Q).tu=k-1;

//計算各行第一個非零元素在存儲數(shù)組中的位置

//若該行無非零元，則rpos[]值為零

int num[(*Q).mu+1],row,cpot[(*Q).mu+1];

cpot[1]=1;

for(k=1;k=(*Q).mu;k++)

num[k]=0;

for(k=1;k=(*Q).tu;k++)

++num[(*Q).data[k].i];

for(row=2;row=(*Q).mu;row++)

cpot[row]=cpot[row-1]+num[row-1];

for(row=1;row=(*Q).mu;row++){

if(cpot[row]=(*Q).tu)

if((*Q).data[cpot[row]].i==row){

(*Q).rpos[row]=cpot[row];

}

else

(*Q).rpos[row]=0;

else

(*Q).rpos[row]=0;

}

}

ChaRLSMatrix(RLSMatrix *M,RLSMatrix *N,RLSMatrix *Q)

{//矩陣求差函數(shù)

if((*M).mu!=(*N).mu||(*M).nu!=(*N).nu)

{printf("不滿足矩陣相減的條件!");return 0;}

int i;

for(i=1;i=(*N).nu;i++)

(*N).data.e*=-1;

HeRLSMatrix((*M),(*N),(*Q));

}

JiRLSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix *Q)

{//矩陣求積函數(shù)

int arow,ctemp[N.nu+1],p,tp,i=1,j=1,t,q,ccol,h=1,n=1;

if(M.nu!=N.mu){

printf("不滿足矩陣相乘的條件！");exit(0);}

(*Q).mu=M.mu;(*Q).nu=N.nu;(*Q).tu=0;

if(M.tu*N.tu!=0){

for(arow=1;arow=M.mu;arow++){//處理M的每一行

for(n=0;nN.nu+1;n++)

ctemp[n]=0;//當前行累加器清零

if(M.rpos[arow]!=0){//若arow行無非零元，則計算下一個有非零元的行

p=M.rpos[arow];

if(arowM.mu){

if(M.rpos[arow+1]==0){

if(arow+1M.mu){

while(arow+iM.muM.rpos[arow+i]==0)

i++;

tp=M.rpos[arow+i];

if(tp==0)

tp=M.tu+1;

}

else tp=M.tu+1;

}

else tp=M.rpos[arow+1];

}

else tp=M.tu+1;

for(p;ptp;p++){//對當前行中的每一個非零元

if(N.rpos[M.data[p].j]!=0){

q=N.rpos[M.data[p].j];//若該行存在非零元，找到對應元在N中的行號

if(M.data[p].jN.mu){

if(N.rpos[M.data[p].j+1]==0){

if(M.data[p].j+1N.mu){

while(M.data[p].j+1N.muN.rpos[M.data[p].j+j]==0)

j++;

t=N.rpos[M.data[p].j+j];

if(t==0)

t=N.tu+1;

}

else t=N.tu+1;

}

else t=N.rpos[M.data[p].j+1];

}

else t=N.tu+1;

for(q;qt;q++){

ccol=N.data[q].j;

ctemp[ccol]+=M.data[p].e*N.data[q].e;

}

}

}//求得Q中第arow行的非零元

for(ccol=1;ccol=N.nu+1;ccol++)//存儲該行的非零元到Q中

if(ctemp[ccol]){

if(hMAXSIZE){printf("非零個數(shù)超出定義范圍！");exit(0);}

(*Q).data[h].i=arow;

(*Q).data[h].j=ccol;

(*Q).data[h].e=ctemp[ccol];

h++;

}

}

}

}

(*Q).tu=h-1;

//計算各行第一個非零元素在存儲數(shù)組中的位置

//若該行無非零元，則rpos[]值為零

int num[(*Q).mu+1],row,cpot[(*Q).mu+1],k;

cpot[1]=1;

for(k=1;k=(*Q).mu;k++)

num[k]=0;

for(k=1;k=(*Q).tu;k++)

++num[(*Q).data[k].i];

for(row=2;row=(*Q).mu;row++)

cpot[row]=cpot[row-1]+num[row-1];

for(row=1;row=(*Q).mu;row++){

if(cpot[row]=(*Q).tu)

if((*Q).data[cpot[row]].i==row){

(*Q).rpos[row]=cpot[row];

}

else

(*Q).rpos[row]=0;

else

(*Q).rpos[row]=0;

}

}

main()

{

RLSMatrix M,N,Q;

char ch;

printf(" *************************** \n");

printf(" ** ** \n");

printf(" ** 稀疏矩陣運算器 ** \n");

printf(" ** --------------------- ** \n");

printf(" *************************** \n");

printf(" _____________________________________________________________________ \n");

printf(" | 請選擇 | \n");

printf(" | A.加法 B.減法 C.乘法 D.轉置 Y.繼續(xù)運算 N.結束運算 | \n");

printf(" |_____________________________________________________________________| \n\n");

printf("\2 輸入數(shù)字時請用逗號隔開！\n\n");

printf(" -");

scanf("%c",ch);

while(ch!='N'){//進行循環(huán)運算

switch(ch){//進行運算選擇

case'A':{ printf(" 請輸入要求和的兩個矩陣：\n\n");

printf(" 輸入第一個矩陣：\n\n");

ScanRLSMatrix(M);

printf(" 輸入的第一個矩陣為：\n\n");

PrintRLSMatrix(M);

printf(" 輸入第二個矩陣：\n\n");

ScanRLSMatrix(N);

printf(" 輸入的第二個矩陣為：\n\n");

PrintRLSMatrix(N);

HeRLSMatrix(M,N,Q);

printf(" 兩矩陣之和為：\n\n");

PrintRLSMatrix(Q);

printf(" 是否繼續(xù)運算（Y/N）？\n\n");

printf(" -");

ch=getchar();

};break;

case'B':{ printf(" 請按次序輸入要求差的兩個矩陣：\n\n");

printf(" 輸入第一個矩陣：\n\n");

ScanRLSMatrix(M);

printf(" 輸入的第一個矩陣為：\n\n");

PrintRLSMatrix(M);

printf(" 輸入第二個矩陣：\n\n");

ScanRLSMatrix(N);

printf(" 輸入的第二個矩陣為：\n\n");

PrintRLSMatrix(N);

ChaRLSMatrix(M,N,Q);

printf(" 兩矩陣之差為：\n\n");

PrintRLSMatrix(Q);

printf("是否繼續(xù)運算（Y/N）？\n\n");

printf(" -");

ch=getchar();

}break;

case'C':{printf(" 請按次序輸入要求積的兩個矩陣：\n\n");

printf(" 輸入第一個矩陣：\n\n");

ScanRLSMatrix(M);

printf(" 輸入的第一個矩陣為：\n\n");

PrintRLSMatrix(M);

printf(" 輸入第二個矩陣：\n\n");

ScanRLSMatrix(N);

printf(" 輸入的第二個矩陣為：\n\n");

PrintRLSMatrix(N);

JiRLSMatrix(M,N,Q);

printf(" 兩矩陣之積為：\n\n");

PrintRLSMatrix(Q);

printf("是否繼續(xù)運算（Y/N）？\n\n");

printf(" -");

ch=getchar();

}break;

case'D':{printf("請輸入要轉置的矩陣：\n\n");

ScanRLSMatrix(M);

printf(" 輸入的要轉置的矩陣為：\n\n");

PrintRLSMatrix(M);

FasttransposeRLSMatrix(M,Q);

printf("轉置矩陣為：\n\n");

PrintRLSMatrix(Q);

printf("是否繼續(xù)運算（Y/N）？\n\n");

printf(" -");

ch=getchar();

}break;

case'Y':{printf("請選擇運算\n");

printf(" -");

ch=getchar();

}break;

default:printf("-");ch=getchar();break;

}

}

printf(" 運算結束！\n\n");

printf(" \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1謝謝使用!\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\n\n");

getch();

}

java編寫稀疏矩陣

/*我寫的一個例子，基本上將稀疏矩陣三元組存儲結構的定義和其有關的算法都實現(xiàn)了，那java語言改變?nèi)グ桑?/p>

#includestdio.h

#define MAXSIZE 1000//非零元素的個數(shù)最多為1000

typedef struct {

int row;

int col;

int e;

}Triple;

typedef struct{

Triple data[MAXSIZE];//非零元素的三元組表

int m;//矩陣的行數(shù)

int n;//矩陣的列數(shù)

int non_zero_num;//非零元數(shù)的個數(shù)

}XSMatrix;

XSMatrix XSM_Info_Input(XSMatrix s){

int i;

printf("輸入矩陣的行數(shù)：");

scanf("%d",s.m);

printf("輸入矩陣的列數(shù)：");

scanf("%d",s.n);

printf("輸入矩陣的非零元素的個數(shù)：");

scanf("%d",s.non_zero_num);

for(i=0;is.non_zero_num;i++){

printf("輸入第%d個非零元數(shù)的信息：\n",i+1);

printf("行下標:");

scanf("%d",s.data[i].row);

printf("列下標:");

scanf("%d",s.data[i].col);

printf("元素的值");

scanf("%d",s.data[i].e);

}

return s;

}

void XSM_Info_Output(XSMatrix s){

int i;

printf("\n稀疏矩陣行數(shù)和列數(shù)：%d\t%d\n",s.m,s.n);

printf("稀疏矩陣三元組表如下：\n");

printf("行下標\t列下標\t值\n");

for(i=0;is.non_zero_num;i++){

printf("%d\t%d\t%d\n",s.data[i].row,s.data[i].col,s.data[i].e);

}

}

//列序遞增轉置法

XSMatrix TransXSM(XSMatrix s){

XSMatrix d;

int i,j,k=0;

d.m=s.n;

d.n=s.m;

d.non_zero_num=s.non_zero_num;

for(i=0;is.n;i++){

for(j=0;js.non_zero_num;j++){

if(s.data[j].col==i)

{

d.data[k].row=s.data[j].col;

d.data[k].col=s.data[j].row;

d.data[k].e=s.data[j].e;

k++;

}

}

}

return d;

}

main(){

XSMatrix source,dest;

source=XSM_Info_Input(source);

XSM_Info_Output(source);

dest=TransXSM(source);

XSM_Info_Output(dest);

}

比較兩個稀疏矩陣三元組行的單鏈表是否相等java代碼

此程序我做了測試沒問題

編譯軟件（virtual c++ 6.0）望你能學習進步

#includeiostream.h

#includestdlib.h

#includeiomanip.h

#define MaxRows 100

#define MaxColumns 100

typedef int ElemType;

struct CrossNode

{

int row,col;

ElemType val;

CrossNode *down,*right;

};

struct CLMatrix

{

int m,n,t;

CrossNode *rv[MaxRows+1];

CrossNode *cv[MaxColumns+1];

};

void InitMatrix(CLMatrix M)

{

M.m=0;M.n=0;M.t=0;

for(int i=1;i=MaxRows;i++)

M.rv[i]=NULL;

for(i=1;i=MaxColumns;i++)

M.cv[i]=NULL;

}

void InputMatrix(CLMatrix M,int m,int n);

void OutputMatrix(CLMatrix M,int m,int n);

void Transpose(CLMatrix M,int m,int n);

void main()

{

CLMatrix Q,P,N;

InitMatrix(Q);

InitMatrix(P);

InitMatrix(N);

cout"請您輸入矩陣的行數(shù)與列數(shù)：";

int m,n;

cinmn;

cout"請以三元組的形式進行輸入:"endl;

InputMatrix(Q,m,n);

cout"您輸入的稀疏矩陣為："endl;

OutputMatrix(Q,m,n);

cout"轉置后的稀疏矩陣為："endl;

Transpose(Q,m,n);

}

void InputMatrix(CLMatrix M,int m,int n)

{

M.m=m;M.n=n;

int row,col,val;

int k=0;

cinrowcolval;

while(row!=0)

{

k++;

CrossNode *cp,*newptr;

newptr=new CrossNode;

newptr-row=row;

newptr-col=col;

newptr-val=val;

newptr-down=newptr-right=NULL;

cp=M.rv[row];

if(cp==NULL)

M.rv[row]=newptr;

else

{

while(cp-right!=NULL)

cp=cp-right;

cp-right=newptr;

}

cp=M.cv[col];

if(cp==NULL)

M.cv[col]=newptr;

else

{

while(cp-down!=NULL)

cp=cp-down;

cp-down=newptr;

}

cinrowcolval;

}

M.t=k;

}

void Transpose(CLMatrix M,int m,int n)

{

CLMatrix S;

InitMatrix(S);

S.m=M.m;S.n=M.n;

for(int i=1;i=S.m;i++)

{

for(int j=1;j=S.n;j++)

{

int val=0;

CrossNode *cp,*newptr;

newptr=new CrossNode;

newptr-row=i;

newptr-col=j;

newptr-val=val;

newptr-down=newptr-right=NULL;

cp=S.rv[i];

if(cp==NULL)

S.rv[i]=newptr;

else

{

while(cp-right!=NULL)

cp=cp-right;

cp-right=newptr;

}

cp=S.cv[j];

if(cp==NULL)

S.cv[j]=newptr;

else

{

while(cp-down!=NULL)

cp=cp-down;

cp-down=newptr;

}

}

}

for(i=1;i=M.m;i++)

{

CrossNode *sp1=S.rv[i];

CrossNode *mp1=M.rv[i];

while(mp1!=NULL)

{

while(sp1-colmp1-col)

sp1=sp1-right;

sp1-val=mp1-val;

mp1=mp1-right;

}

}

for(int x=1;x=S.m;x++)

{

while(S.cv[x]!=NULL)

{

coutsetw(4)S.cv[x]-val;

S.cv[x]=S.cv[x]-down;

}

coutendl;

}

}

void OutputMatrix(CLMatrix M,int m,int n)

{

CLMatrix S;

InitMatrix(S);

S.m=M.m;S.n=M.n;

for(int i=1;i=S.m;i++)

{

for(int j=1;j=S.n;j++)

{

int val=0;

CrossNode *cp,*newptr;

newptr=new CrossNode;

newptr-row=i;

newptr-col=j;

newptr-val=val;

newptr-down=newptr-right=NULL;

cp=S.rv[i];

if(cp==NULL)

S.rv[i]=newptr;

else

{

while(cp-right!=NULL)

cp=cp-right;

cp-right=newptr;

}

cp=S.cv[j];

if(cp==NULL)

S.cv[j]=newptr;

else

{

while(cp-down!=NULL)

cp=cp-down;

cp-down=newptr;

}

}

}

for(i=1;i=M.m;i++)

{

CrossNode *sp1=S.rv[i];

CrossNode *mp1=M.rv[i];

while(mp1!=NULL)

{

while(sp1-colmp1-col)

sp1=sp1-right;

sp1-val=mp1-val;

mp1=mp1-right;

}

}

for(int x=1;x=S.m;x++)

{

while(S.rv[x]!=NULL)

{

coutsetw(4)S.rv[x]-val;

S.rv[x]=S.rv[x]-right;

}

coutendl;

}

}

JAVA稀疏矩陣運算器

2 設計

2.1 用十字鏈表存儲稀疏矩陣

為了能有效存儲稀疏矩陣的元素， 本文采用十字鏈表對數(shù)據(jù)進行存儲， 所設計的十字鏈表C++語言描述如下： Typedef struct OLNode{

Int　 i , j ;

ElemType e;

Struct OLNode * right, * down;

}OLNode; *OLink;

Typedef struct{

OLink * rhead, * chead;

　 Int　 mu,nu,tu;

}CrossList;

2.2 稀疏矩陣相乘主要算法設計

稀疏矩陣乘法運算器的設計主要設計到稀疏矩陣的創(chuàng)建和相乘運算， 下面給出這兩個過程的C++語言描述為：

2.2.1 稀疏矩陣的創(chuàng)建 Statue CreateSMatrix_OL (CrossList M){

//創(chuàng)建稀疏矩陣M。

If (M)　 free(M);

Scanf (m,n,t);

M.mu:=m;　 M.nu:=n;　 M.tu:=t;

If　 (! ( M.rhead=(OLink * )malloc( (m+1) * sizeof(OLink) ) ) ) exit (OVERFLOW)

If　 (! ( M.chead=(OLink * )malloc( (n+1) * sizeof(OLink) ) ) ) exit (OVERFLOW)

M.rhead[　 ]+M.chead[　 ]=NULL;

For ( scanf( i, j, e); i!=0 ; scanf ( I, j, e ) ){

　 If(! ( p=(OLNode * )malloc( sizeof (OLNode) ) ) ) exit ( OVERFLOW )

　 P—i = i; p—j=j ; p—e=e;

　 If (M . rhead [ i ] = =NULL)　 M . rhead [ i ] = p;

　 Else{

For ( q = M . rhead [ i ]; ( q—right ) q— right— j j;　 q = q— right;)

p—right =q—right ;　 q—right=p;　 }

JAVA編寫程序對稀疏矩陣進行轉置。 要求:使用稀疏矩陣的三元組存儲實現(xiàn)

這個自己寫吧，很容易的。比如稀疏矩陣里的三元組[row,col,value]，轉置之后就是[col,row,value]