稀疏矩陣的行邏輯連結表示
阿新 • • 發佈：2019-01-13
<p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> //三元組順序表又稱有序的雙下標法，它的特點是：非零元在表中按行序列有序儲存，因此便於進行依行順序處理的矩陣運算。
//然而若需要按行號存取某一行的非零元，則需要從頭開始查詢。
//為便於隨機存取任意一行的非零元，則需知道每一行的第一個非零元在三元組表中的位置。
//為此,可將上節快速轉置矩陣的<a target=_blank href="http://lib.csdn.net/base/31" class="replace_word" title="演算法與資料結構知識庫" target="_blank" style="text-decoration: none; color: rgb(223, 52, 52); font-weight: bold;">演算法</a>中建立的，指示“行”資訊的輔助陣列cpot固定在稀疏矩陣的儲存結構中，這種“帶行連結資訊”的三元組表為行邏輯連結順序表</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">//------------處理乘法有優勢------------//
#include < stdio.h >
#include < stdlib.h ></p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define UNDERFLOW -3</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">#define MAXSIZE 12500 //非零元個數的最大值
#define MAXRC 100 //行數</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">typedef int Status; //函式一般有返回值最好，即使沒有用，也可以用來判斷
typedef int ElemType ; </p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">typedef struct
{
int row , col ; //非零元素的行下標和列下標
ElemType e ; </p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">} Triple ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">typedef struct
{
Triple data[ MAXSIZE + 1 ] ; //非零元的三元組，data[0]未用
int mu , nu , tu ; //此處是矩陣的行數(mu)、列數(nu)而不是三元組的行數和列數 . 非零元個數(tu)
int rpos[ MAXRC + 1 ] ; //各行第一個非零元的位置表</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">} TSMatrix ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">//-----------------Function------------------//
/*Status SetRposA( TSMatrix M ) //此處考慮的是在無非零元的行,其rpos 均為 0 。//而書本上考慮的是在無非零元的行，其rpos為上一行的rpos.
{ //計算rpos[ ]值
//rpos[ row ] 指示矩陣M的第row行中第一個非零元在M.data(三元組矩陣)中的序號
//而( rpos[ row + 1 ] - 1 )則指示矩陣M的第row行中最後一個非零元在M.data(三元組矩陣)中的序號
//而最後一行中最後一個非零元在M.data中的位置顯然就是M.tu了！
int i , j , count , k = 0 ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> for( i = 1 ; i <= M.mu ; ++ i ) //無非零元的行，其rpos均為0
{
rpos[ i ] = 0 ;
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> i = M.data[ 1 ].row ; //第一個非零元素的行下標
M.rpos[ i ] = 1 ;
for( ; i < M.mu ; ++ i ) //不能從第一行開始計算，因為第一行可能沒有非零元
{
count = 0 ;
for( j = 1 ; j <= M.tu ; ++ j )
{
if( M.data[ j ].row == i )
{
count ++ ; //統計一行的非零元個數
}
if( M.data[ j ].row > i )
{
break ;
}
} //for</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> if( count != 0 )
{
M.rpos[ i + 1 ] = M.rpos[ i - k ] + count ; //中間也可能有些行不存在非零元(i- k)
k = 0 ;
}
else
{
++ k ;
}
} //for</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> return OK ;
}*/</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">Status SetRposB( TSMatrix &M )
{
int i , row ;
int * num ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> num = ( int * )malloc( ( M.nu + 1 ) * sizeof( int ) ) ;
//統計每行的非零元的個數
for( row = 1 ; row <= M.mu ; ++ row )
{
num[ row ] = 0 ;
}
for( i = 1 ; i <= M.tu ; ++ i )
{
++ num[ M.data[ i ].row ] ; //M.data為哪行，則增加哪行的元素個數
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> //統計每個第一個非零元在三元組中的位置
/* for( row = 1 ; i <= M.data[ 1 ].row ; i ++ ) //開始沒有非零元的幾行，均賦值為1
{
M.rpos[ i ] = 1 ;
}
for( i = 2 ; i <= M.tu ; ++ i )
{
if( M.data[ i ].row > M.data[ i - 1 ].row ) //row 為行下標 //到了另一行，因為同一行的元素，只需統計第一個非零元即可
{
for( j = 0 ; j < M.data[ i ].row - M.data[ i-1 ].row ; ++ j )
{
M.rpos[ M.data[ i ].row - j ] = i ; //求理解！
}
}
}
for( i = M.data[ M.tu ].row + 1 ; i <= M.mu ; ++ i ) // 給最後沒有非零元素的幾行賦值
{
M.rpos[ i ] = M.tu + 1 ;
} */</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">
M.rpos[ 1 ] = 1 ;
for( row = 2 ; row <= M.mu ; ++ row )
{
M.rpos[ row ] = M.rpos[ row - 1 ] + num[ row - 1 ] ; //求得行邏輯 ！ 呵呵，同樣三個迴圈呀，還少一個判讀！值呀！嗨！誰叫上面的那句這麼難理解
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> return OK ;
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">Status CreatTSMatrix( TSMatrix &M ) //引數為TSMatrix &M形式，( M.mu 引用) 則只能用C++編譯器，看來少付出是要有代價的呀！！！
{ //而設為TSMatrix *M, 則兩種引用！(M->mu) ,或者 ( (*M).mu )
int i ;
printf( "please input the rows , cols and numbers:" ) ;
scanf( "%d %d %d" , &M.mu , &M.nu , &M.tu ) ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> while( M.mu <= 0 || M.nu <= 0 || M.tu <= 0 || M.tu > M.mu * M.nu )
{
printf( "please input the rows , cols and numbers once again:" ) ;
scanf( "%d %d %d" , &M.mu , &M.nu , &M.tu ) ;
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">// fflush( stdin ) ; //清空緩衝區</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">
//輸入稀疏矩陣元素
printf( "please input the element's row , col and data:" ) ;
for( i = 1 ; i <= M.tu ; i ++ ) //雙for迴圈輸入雖然整體簡潔，但是下面的方法輸入工作較少
{
scanf( "%d %d %d" , &M.data[ i ].row , &M.data[ i ].col , &M.data[ i ].e ) ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> if( ( M.data[ i ].row <= 0 ) || ( M.data[ i ].col <= 0 ) )
{
printf( "input wrong ! please input again !" ) ;
scanf( "%d %d %d" , M.data[ i ].row , M.data[ i ].col , M.data[ i ].e ) ;
}
}
SetRposB( M ) ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> return OK ;
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">Status PrintTSMatrix( TSMatrix T ) //列印三元組表
{
int i ; </p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> printf( "The TSMatrix :\n" ) ;
printf( " i . j . e \n" ) ;
for( i = 1 ; i <= T.tu ; ++ i )
{
printf( "%2d %3d %3d\n" , T.data[ i ].row , T.data[ i ].col , T.data[ i ].e ) ; //以三元組形式輸出
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> printf( "\n" ) ;
return OK ;
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">Status DestroyTSMatrix( TSMatrix &M )
{
int i , k ;
for( i = 1 ; i <= M.tu ; i ++ )
{
M.data[ i ].col = 0 ;
M.data[ i ].row = 0 ;
M.data[ i ].e = 0 ;
}
for( k = 1 ; k <= M.mu ; ++ k )
{
M.rpos[ k ] = 0 ;
}
M.mu = 0 ;
M.nu = 0 ;
M.tu = 0 ;
return OK ;
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">Status CopyTSMatrix( TSMatrix M , TSMatrix &T )
{ // T = M ,直接這樣.資料一樣，首地址不一樣！ &T = &M ,這樣也可以，資料一樣，首地址也一樣！
int k ;
T.mu = M.mu ;
T.nu = M.nu ;
T.tu = M.tu ;
for( k = 1 ; k <= M.tu ; ++ k )
{
T.data[ k ].col = M.data[ k ].col ; //列
T.data[ k ].row = M.data[ k ].row ; //行
T.data[ k ].e = M.data[ k ].e ;
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> for( k = 1 ; k <= M.mu ; ++ k )
{
T.rpos[ k ] = M.rpos[ k ] ;
}
return OK ;
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">
Status AddTSMatrix( TSMatrix M , TSMatrix N , TSMatrix &Q ) // Q = M + N ;
{
int x = 0 , y = 0 ;
int i , j , p , q ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> if( ( M.mu != N.mu ) || ( M.nu != N.nu ) )
{
return ERROR ;
}
Q.mu = M.mu ; //矩陣的行數和列數，而不是三元組行數和列數
Q.nu = M.nu ;
Q.tu = 0 ; </p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> for( i = 1 ; i <= Q.mu ; i ++ ) //注意此處需和輸入處保持一致，行、列下標需從0開始
{
for( j = 1 ; j <= Q.nu ; j ++ )
{
//取M元素
for( p = 1 ; p <= M.tu ; p++ )
{
if( ( i == M.data[ p ].row ) && ( j == M.data[ p ].col ) )
{
x = M.data[ p ].e ;
break ;
}
else
{
x = 0 ;
}
} //////////for p
//取N元素
for( q = 1 ; q <= N.tu ; q ++ )
{
if( ( i == N.data[ q ].row ) && ( j == N.data[ q ].col ) )
{
y = N.data[ q ].e ;
break ;
}
else
{
y = 0 ;
}
} ///////////for q
if( ( x + y ) != 0 )
{
Q.data[ Q.tu + 1 ].row = i ;
Q.data[ Q.tu + 1 ].col = j ;
Q.data[ Q.tu + 1 ].e = x + y ;
Q.tu ++ ;
} ////////if
} //////////for j
} ///////////for i
SetRposB( Q ) ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> return OK ;
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">
Status SubTSMatrix( TSMatrix &M , TSMatrix &N , TSMatrix &Q ) //以前為SubTSMatrix( TSMatrix M , TSMatrix N , TSMatrix &Q )
{ //那樣沒有考慮到裡面AddTAMatrix訪問的要求
int i ;
for( i = 1 ; i <= N .tu ; ++ i )
{
N.data[ i ].e *= -1 ; //強！！
}
AddTSMatrix( M , N , Q ) ; //強！！！
return OK ;
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">Status MultTSMatrix( TSMatrix &M , TSMatrix &N , TSMatrix &Q ) //矩陣相乘
{
int arow , brow , p , q , tp , t , ccol , ctemp[ MAXRC + 1 ] ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> if( M.nu != N.mu )
{
return ERROR ;
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> Q.mu = M.mu ;
Q.nu = N.nu ; //Take care! Not M.nu
Q.tu = 0 ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> if( M.tu * N.tu != 0 ) //Q是非零元矩陣
{
for( arow = 1 ; arow <= M.mu ; ++ arow ) // 從M的第一行開始，到最後一行，arow是M的當前行
{
for( ccol = 1 ; ccol <= M.nu ; ++ ccol )
{
ctemp[ ccol ] = 0 ; //當前行各元素累加器清零
} ///for ccol</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> Q.rpos[ arow ] = Q.tu + 1 ; //Q中第arow行第一個非零元在三元組中的位置
if( arow < M.mu )
{
tp = M.rpos[ arow + 1 ] ; //M中第arow + 1行第一個非零元在三元組中的位置
}
else
{
tp = M.tu + 1 ;
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> for( p = M.rpos[ arow ] ; p < tp ; ++ p )
{ //對當前行中每一個非零元,找到對應在N中的行號
brow = M.data[ p ].col ; //M中列對應N中的行
if( brow < N.mu )
{
t = N.rpos[ brow + 1 ] ;
}
else
{
t = N.tu + 1 ;
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> for( q = N.rpos[ brow ] ; q < t ; ++ q )
{
ccol = N.data[ q ].col ; //乘積元素在Q中的列號
ctemp[ ccol ] += M.data[ p ].e + N.data[ q ].e ;
} ////for q
} ////for p 求得Q中第crow( = arow ) 行的非零元</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> for( ccol = 1 ; ccol <= Q.nu ; ++ ccol )
{ // 壓縮儲存該行非零元
if( ctemp[ ccol ] )
{
if( ++ Q.tu > MAXSIZE )
return ERROR ;
Q.data[ Q.tu ].row = arow ;
Q.data[ Q.tu ].col = ccol ;
Q.data[ Q.tu ].e = ctemp[ ccol ] ;
} ///if
} ///for ccol </p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> } ///for arow
} /// if
return OK ;
} </p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">Status TransposeTSMatrix( TSMatrix M , TSMatrix &Q ) //矩陣轉置
{
int i , col , p , q ;
int * num ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> num = ( int * )malloc( ( M.nu + 1 ) * sizeof( int ) ) ; //下標為0--M.nu ,所以num[ 0 ]可以不用！</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> Q.mu = M.nu ;
Q.nu = M.mu ;
Q.tu = M.tu ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> if( M.tu ) //存在元素
{
for( col = 1 ; col <= M.nu ; ++ col ) //求M矩陣每列非零元個數
{
num[ col ] = 0 ;
}
for( i = 1 ; i <= M.tu ; ++ i )
{
++ num[ M.data[ i ].col ] ; //num[ 0 ] 不用
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> //-------------------------------------------------------------//
Q.rpos[ 1 ] = 1 ; </p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> for( col = 2 ; col <= M.nu ; ++ col ) //求M中第col列中第一個非零元在三元組中的序號，即為Q中第col行第一個非零元在三元組中的序號
{
Q.rpos[ col ] = Q.rpos[ col - 1 ] + num[ col - 1 ] ; //M.nu 等效於 Q.mu
} // Q.rpos 為Q每行的第一個非零元的位置，而其中下標為M中的列</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> //------------------------------------------------------------//
for( col = 1 ; col <= M.nu ; ++ col ) //不解! 求理解! OH!已理解！因為轉置後Q.rpos仍需要，所以不能改變Q.rpos的資料！
{
num[ col ] = Q.rpos[ col ] ; //為矩陣Q中每行第一個非零元在三元組中的位置
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> for( p = 1 ; p <= M.tu ; ++ p ) //求解！ 已解！得自己一個個去實踐！實踐中理解
{
col = M.data[ p ].col ;
q = num[ col ] ; //為矩陣Q中每行第一個非零元在三元組中的位置
Q.data[ q ].row = M.data[ p ].col ;
Q.data[ q ].col = M.data[ p ].row ;
Q.data[ q ].e = M.data[ p ].e ;
++ num[ col ] ; //若Q中某列有多個元素，則下標同樣增大
}
}
free( num ) ;
return OK ;
}</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">int main( )
{
TSMatrix M , T , Q , N ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> CreatTSMatrix( M ) ;
// SetRposB( M ) ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> PrintTSMatrix( M ) ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> CopyTSMatrix( M , T ) ; //不管引數為TSMatrix M 形式, 還是TSMatrix &T 形式，呼叫時均用TSMatrix M ，C++編譯器就是好啊！
PrintTSMatrix( T ) ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">// AddTSMatrix( M , T , Q ) ;
// PrintTSMatrix( Q ) ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">// SubTSMatrix( Q , M , N ) ; //a little wrong ! I'm over it!
// PrintTSMatrix( N ) ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">
MultTSMatrix( M , T , Q ) ; //a little wrong ! I'm over it!
PrintTSMatrix( Q ) ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">// TransposeTSMatrix( M , Q ) ;
// PrintTSMatrix( Q ) ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> DestroyTSMatrix( M ) ;</p><p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;">return 0 ;
}</p>相關推薦
稀疏矩陣的行邏輯連結表示
<p style="margin-top: 0px; margin-bottom: 0px; padding-top: 0px; padding-bottom: 0px;"> //三元組順序表又稱有序的雙下標法，它的特點是：非零元在表中按行序列有序儲存，因此便於
矩陣的壓縮儲存(稀疏矩陣的十字連結串列儲存、稀疏矩陣的三元組行邏輯連結的順序表儲存表示、稀疏矩陣的三元組順序表儲存表示)
// c5-2.h 稀疏矩陣的三元組順序表儲存表示(見圖5.4) #define MAX_SIZE 100 // 非零元個數的最大值 struct Triple { int i,j; // 行下標,列下標 ElemType e; // 非零元素值 }; struct T
矩陣乘法（行邏輯連結的順序表）及程式碼實現
矩陣相乘的前提條件是：乘號前的矩陣的列數要和乘號後的矩陣的行數相等。且矩陣的乘法運算沒有交換律，即 A*B 和 B*A 是不一樣的。 例如，矩陣A： 矩陣B： 由於矩陣 A 的列數和矩陣 B 的行數相等，可以進行 A*B 運算（不能進行 B*A 運算）。計算方法是：用矩陣A的第 i 行和矩陣B中的每
資料結構（二）:線性表的使用原則以及連結串列的應用-稀疏矩陣的三元組表示
下面先對沒有介紹的連結串列中的雙鏈表進行介紹，並通過稀疏矩陣的三元組的鏈式結構來深入理解較為複雜的連結串列儲存結構。最後對三次博文所講述的內容進行梳理，以幫助在實際應用中選擇最合適的儲存結構：順序表
數據結構（二）:線性表的使用原則以及鏈表的應用-稀疏矩陣的三元組表示
查找 triple 表的操作 結構 循環鏈表 循環 大於 ria 幫助 上一篇博文中主要總結線性表中的鏈式存儲結構實現，比方單向鏈表、循環鏈表。還通過對照鏈表和順序表的多項式的存儲表示。說明鏈表的長處。能夠參看上篇博文http://blog.csdn.net/lg125
稀疏矩陣的十字連結串列
#include<stdio.h> #include<string.h> #include<stdlib.h> typedef struct node {int hang,lie,zhi; struct node *xia,*you; }node,* l
演算法：稀疏矩陣之三元組表示
三元組的表示 （1）、目的：對於在實際問題中出現的大型的稀疏矩陣，若用常規分配方法在計算機中儲存，將會產生大量的記憶體浪費，而且在訪問和操作的時候也會造成大量時間上的浪費，為了解決這一問題，從而善生了多種解決方案。 （2）、由於其自身的稀疏特性，通過壓縮可以大大節省稀疏矩
三元組順序表，稀疏矩陣的三元組表示法
三元組順序表，用於稀疏矩陣的儲存，因此經常被稱為係數矩陣的三元組表示，它們是一個意思。 稀疏矩陣，即包含大量值為 0 的矩陣，此類矩陣的一種儲存方法是將矩陣中所有非 0 元素所在的位置（行標和列標）和元素值儲存在順序表（陣列）中，通過儲存由所有非 0 元素的三元組構成的順序表，以及該稀疏矩陣的行數和列數，即
資料結構之自建演算法庫——稀疏矩陣的三元組表示
稀疏矩陣的三元組表示相關的演算法庫採用程式的多檔案組織形式，包括兩個檔案： 1.標頭檔案：tup.h，包含定義稀疏矩陣的三元組表示資料結構的程式碼、巨集定義、要實現演算法的函式的宣告； #ifndef TUP_H_INCLUDED #define
第九周專案三：稀疏矩陣的三元組表示的實現及應用（2）
/* Copyright (c)2015,煙臺大學計算機與控制工程學院 All rights reserved. 檔名稱：專案3-2.cbp 作 者：孫立立 完成日期：2015年12月4日 版 本 號：v1.0 問題描述：（2）採用三元組儲存稀疏矩陣，設計兩個稀疏
稀疏矩陣的三元組表示的實現及應用（2）——採用三元組儲存稀疏矩陣，設計兩個稀疏矩陣相加的運算演算法
/* *Copyright (c) 2015 , 煙臺大學計算機學院 *All right resvered . *檔名稱: 稀疏矩陣.cpp *作 者: 鄭兆涵 *稀疏矩陣的三元組表示的實現及應用（2） */ 問題：稀疏矩
稀疏矩陣的十字連結串列實現：行列連結串列
<span style="font-size:12px;">//將current插入到其對應的行連結串列的合適位置，使行連結串列的元素按行號遞增順序排列 void Insert_R( OLNode *rhead, OLNode * current ) { if( ( rhead + cu
稀疏矩陣的三元組表示的實現及應用（1）——建立稀疏矩陣三元組表示的演算法庫
/* *Copyright (c) 2015 , 煙臺大學計算機學院 *All right resvered . *檔名稱: 稀疏矩陣.cpp *作 者: 鄭兆涵 *稀疏矩陣的三元組表示的實現及應用（1） */ 問題：稀疏
python稀疏矩陣的儲存與表示
from scipy import sparse help(sparse) 其中顯示了可以表示的7種稀疏矩陣型別： There are seven available sparse matrix types: 1. csc_matr
行邏輯三元組稀疏矩陣加減乘的程式設計實現
目的： 程式設計實現稀疏矩陣的四則運算。 實現： 1. 稀疏矩陣的儲存結構採用行邏輯表示的三元組 2. #define MAXSIZE 12500 #define MAXRC 12500 typedef struct {
稀疏矩陣(三元組表示)基本操作 實驗報告 （轉置，加法，乘法）
一、 實驗內容 稀疏矩陣的壓縮儲存結構，以及稀疏矩陣的三元組表表示方法下的轉置、相加、相乘等演算法 二、 實驗目的 1. &n
三元組順序表表示的稀疏矩陣的初始化和快速轉置
//三元組順序表表示的稀疏矩陣的初始化 #include <stdio.h> #include<stdlib.h> #include"constant.h" #define MAXSIZE 12500//假設非零元最大個數為12500 typedef int ElemT
稀疏矩陣——三元組十字連結串列的C語言實現
粗淺學習稀疏矩陣——三元組十字連結串列。 程式碼實現了新建矩陣、矩陣相加、矩陣逆置和矩陣列印在螢幕上。 慚愧於命名規範和程式設計水平，不足的地方請大牛們多多指教： 直接上程式碼 crosslist.h #ifndef _crosslist_h_ #define
資料結構 有序陣列表示稀疏矩陣
一般儲存矩陣，自然想到二維資料。但是對於稀疏矩陣（0項很多），這無疑浪費的大量的空間。所以，這裡考慮換一種表示方法。用一個三元組表示矩陣中的非零元素。 //(稀疏)矩陣資料結構, 待表示矩陣如下 // 15 0 0
三元組順序結構實現稀疏矩陣相加，行序優先(Java語言描述)
不用十字連結串列也可以稀疏矩陣相加時間複雜度最壞情況達到O(tuA + tuB);思路比較簡單就不贅述了，程式碼如下： 三元組： package 行邏輯連結的順序表實現稀疏矩陣的相乘; public class Triple<T> { int row,col