A. 三元組位元組數
三元組的內容為 X下標（1位元組）,Y下標(1位元組）,整形數（4位元組）,每個三元組的位元組數為6,10個非零元素三元組表所需的最少位元組數是 10*6 = 60,此外,應該還需要一個2位元組的變數來表明非零元素個數.
B. 什麼是數據結構中的二元組、三元組和五元組
二元組的定義:<K,R>
三元組的定義:<D,F,A>
五元組的定義:<V,O,G,M,S>
V是值的集合,O是操作的集合,G是構成名字的文法,M是存儲的集合,S是從G能構成的名字幾個到M的映射.
C. 抽象數據類型三元組的定義什麼意思
三元組指形如（（x，y），z）的集合（這就是說，三元組是這樣的偶，其第一個射影亦是一個偶），常簡記為（x，y，z）。
三元組為計算機專業的一門公共基礎課程——數據結構里的概念。主要用來存儲稀疏矩陣的一種壓縮方式，也叫三元組表。假設以順序存儲結構來表示三元組表（triple table），則得到稀疏矩陣的一種壓縮存儲方式，即三元組順序表，簡稱三元組表。
(3)三元組存儲兩個位元組擴展閱讀
抽象數據類型的特徵主要體現在以下幾個方面：
1、數據抽象。用ADT描述程序處理的實體時，強調的是其本質的特徵、其所能完成的功能以及它和外部用戶的介面（即外界使用它的方法）。
2、數據封裝。將實體的外部特性和其內部實現細節分離，並且對外部用戶隱藏其內部實現細節，它包含兩層含義：
將數據和其行為結合在一起，形成一個不可分割的獨立單位；信息隱藏，即盡可能隱藏數據內部細節，只留有限的對外介面形成一個邊界，與外部發生聯系。封裝的原則使得軟體錯誤能夠局部化，大大降低排錯的難度，便於軟體的維護。
3、繼承性。數據封裝使得一個類型可以擁有一般類型的數據和行為，即對一般類型的繼承。若特殊類型從多個一般類型中繼承相關的數據和行為，則為多繼承。
4、多態性。多態性指在一般類型中定義的數據或行為被特殊類型繼承後，具有不同的數據類型或呈現出不同的行為。例如，「蘋果」是「水果」的子類，它可以有「水果」的一般「吃」法，但其本身還可以有別的多種「吃法」。
D. 急！三元組順序表的存儲結構形成
/*~~~~稀疏矩陣的三元組順序表存儲結構類型定義及部分常見操作演算法（smatrix.c）~~~~*/
#ifndef __SPARSEMATRIX__
#define __SPARSEMATRIX__
#ifndef COMMONELEM
#define COMMONELEM 0 /*公共元的值*/
#endif
#include <stdlib.h>
/*三元組順序表存儲空間長度的最小值*/
#define MATRIXMINSIZE 10
/*三元組順序表存儲結構類型定義*/
typedef struct
{
int row; /*行號*/
int col; /*列號*/
MatrixDT value; /*特殊元的值*/
}ThrElem; /*三元組元素類型*/
typedef struct
{
ThrElem *base; /*三元組表的基地址*/
int listsize; /*三元組表的存儲空間尺寸*/
int len; /*三元組表的長度，即矩陣中特殊元的個數*/
int rows,cols; /*矩陣的行數、列數*/
}SMatrix;
/*矩陣初始化*/
void MatrixInitialize(SMatrix *pM, int size, int rows, int cols)
{
if(size<MATRIXMINSIZE)
size=MATRIXMINSIZE;
pM->listsize = size;
pM->base=(ThrElem *)malloc(pM->listsize*sizeof(ThrElem));
if(!pM->base)
exit(EXIT_FAILURE);
pM->rows=rows;
pM->cols=cols;
pM->len=0;
}
/*輸出矩陣*/
void MatrixPrint(SMatrix M, void (*cout)(MatrixDT))
{
int i,j,k;
for(k=0,i=0; i<M.rows; i++)
{
for(j=0; j<M.cols; j++)
if(k<M.len && i==M.base[k].row && j==M.base[k].col)
(*cout)(M.base[k++].value);/*輸出特殊元*/
else
(*cout)(COMMONELEM); /*輸出公共元*/
printf("\n");
}
}
/*取矩陣元素*/
BOOL GetElem(SMatrix M, MatrixDT *pd, int i, int j)
{
int k, addr;
BOOL flg=TRUE;
if(i<0 || i>M.rows-1 || j<0 || j>M.cols-1)
flg=FALSE;/*訪問越界*/
else
{
*pd = COMMONELEM;
/*
由於三元組順序表中特殊元是按"以行優先的順序並保持同一行中列號從小到大的
規律"保存的，故，可以把矩陣中每個特殊元的二元（行號和列號）邏輯地址轉換
成遞增有序的一元偽地址addr=行號*列數+列號；
本演算法採用的是最簡單的順序查找方法。
由於關鍵字序列是遞增有序的,所以也可以使用折半查找（詳見第10章）等演算法，
那樣效率會更高。
*/
addr=i*M.cols+j;
for(k=0; k<M.len && M.base[k].row*M.cols +M.base[k].col <addr; k++)
;
if(k<M.len && i==M.base[k].row && j==M.base[k].col)
/*M[i][j]是特殊元*/
*pd = M.base[k].value;
}
return flg;
}
/*寫矩陣元素*/
BOOL PutElem(SMatrix *pM, MatrixDT d, int i, int j,
BOOL (*equal)(MatrixDT,MatrixDT))
{
int k,m,addr;
BOOL flg=TRUE;
if(i<0 || i>pM->rows-1 || j<0 || j>pM->cols-1 || pM->len >=pM->listsize)
flg=FALSE;/*訪問越界*/
else
{
addr=i*pM->cols +j;
/*掃描到i行中j列元素應在的位置*/
for(k=0;k<pM->len &&
pM->base[k].row* pM->cols +pM->base[k].col<addr; k++)
;
if(k<pM->len && i==pM->base[k].row && j==pM->base[k].col)
{
/*原來是特殊元*/
if((*equal)(d,COMMONELEM))
{
/*第1種情況：原來是特殊元，寫入的是公共元值。從表中刪除元素*/
for(m=k+1; m<pM->len; m++)
pM->base[m-1]=pM->base[m];
pM->len--;
}
else
/*第2種情況：原來是特殊元，寫入的是特殊元值，更改元素值*/
pM->base[k].value=d;
}
else /*原來是公共元*/
{
if(!(*equal)(d,COMMONELEM))
{
/*第3種情況：原來是公共元，寫入的是特殊元值。在表中k位置插入新元素*/
for(m=pM->len-1; m>=k; m--)
pM->base[m+1]=pM->base[m];
pM->base[k].row=i;
pM->base[k].col=j;
pM->base[k].value =d;
pM->len++;
}
else
/*第4種情況：原來是公共元，寫入的是公共元值。空操作*/
;
}
}
return flg;
}
/*拷貝矩陣*/
void MatrixCopy(SMatrix* pM, SMatrix M)
{
int i;
pM->listsize = M.listsize;
pM->rows = M.rows;
pM->cols = M.cols;
pM->len = M.len;
/*申請存儲空間*/
pM->base=(ThrElem *)malloc(pM->listsize*sizeof(ThrElem));
if(!pM->base)
exit(EXIT_FAILURE);
for(i=0; i<pM->len; i++)
pM->base[i]=M.base[i];/*復制數組中單元的值*/
}
/*矩陣加法*/
BOOL MatrixAdd(SMatrix* pM, SMatrix M, SMatrix N,
MatrixDT (*add)(MatrixDT,MatrixDT),BOOL (*equal)(MatrixDT,MatrixDT))
{
int i,j,k,addrM,addrN;
/*pM所指矩陣有可能是矩陣M或矩陣N，故先用base緩存結果，最後再給pM->base*/
ThrElem *base;
MatrixDT d;
BOOL flg=TRUE;
if(M.rows !=N.rows || M.cols!=N.cols)
flg=FALSE;
else
{
base=(ThrElem*)malloc((M.len + N.len)*sizeof(ThrElem));
if(!base)
exit(EXIT_FAILURE);
/*i、j和k分別指示M.base、N.base和臨時數據區base的首位置*/
i=j=k=0;
while(i<M.len && j<N.len)
{
/*計算矩陣M和矩陣N遞增有序的一元偽地址addrM和addrN*/
addrM=M.base[i].row*M.cols + M.base[i].col;
addrN=N.base[j].row*N.cols + N.base[j].col;
if(addrM==addrN)/*兩個矩陣中存在位置相同的特殊元*/
{
/*d是兩個位置相同的特殊元相加之和*/
d=(*add)(M.base[i].value , N.base[j].value);
if(!(*equal)(d, COMMONELEM))
{
/*d是特殊元,把（i,j,d）追加到base數組*/
base[k].row =M.base[i].row;
base[k].col =M.base[i].col;
base[k++].value =d;
}
i++;
j++;
}
else if(addrM < addrN) /*矩陣M中當前特殊元應先追加到base數組*/
{
base[k]=M.base[i++];
base[k++].value=(*add)(base[k].value, COMMONELEM);
}
else /*矩陣N中當前特殊元應先追加到base數組*/
{
base[k++]=N.base[j++];
base[k++].value=(*add)(base[k].value, COMMONELEM);
}
}
/*將矩陣M或矩陣N中剩餘的特殊元追加到base數組*/
for(; i<M.len; i++)
{
base[k]=M.base[i++];
base[k++].value=(*add)(base[k].value, COMMONELEM);
}
for(; j<N.len; j++)
{
base[k]=N.base[j++];
base[k++].value=(*add)(base[k].value, COMMONELEM);
}
if(k>pM->listsize)
exit(EXIT_FAILURE);
/*復制結果數據到pM->base區*/
for(i=0; i<k; i++)
pM->base[i]=base[i];
free(base);
pM->rows=M.rows;
pM->cols=M.cols;
pM->len =k;
}
return flg;
}
/*矩陣轉置*/
void MatrixTranspose(SMatrix *pM, SMatrix M)
{
int col,i,j;
ThrElem *base;
/*
本函數允許如下調用方式：
MatrixTranspose(&m, m);
所以要額外申請存儲空間base
*/
base=(ThrElem*)malloc(M.listsize*sizeof(ThrElem));
if(!base)
exit(EXIT_FAILURE);
for(i=0,col=0; col<M.cols; col++) /*col是轉置後矩陣的行號*/
for(j=0; j<M.len; j++)
if(M.base[j].col == col)
{
/*特殊元行列對換後寫入新表空間*/
base[i].row = M.base[j].col;
base[i].col = M.base[j].row;
base[i].value = M.base[j].value;
i++;
}
pM->listsize =M.listsize;
pM->len =M.len;
pM->rows=M.cols;
pM->cols=M.rows;
free(pM->base);
pM->base=base;
}
/*銷毀矩陣*/
void MatrixDestroy(SMatrix M)
{
free(M.base);
}
#endif
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
/*
建議性測試用程序
*/
typedef enum {TRUE=1,FALSE=0} BOOL;
typedef int MatrixDT;
#include "smatrix.c"
#define inFORMAT "%d"
#define outFORMAT "%3d"
void printdata(MatrixDT x)
{
printf(outFORMAT,x);
}
MatrixDT add(MatrixDT x, MatrixDT y)
{
return x+y;
}
BOOL equal(MatrixDT x, MatrixDT y)
{
return x==y ? TRUE: FALSE;
}
void main()
{
int i,j,x, y, tlimit;
MatrixDT d;
SMatrix M,N;
BOOL valid=TRUE;
printf("請輸入矩陣M的行數、列數及特殊元個數的上限值：\n");
scanf("%d%d%d",&x,&y, &tlimit);
MatrixInitialize(&M,tlimit, x, y);
while(valid)
{
printf("請輸入特殊元的行號、列號(行號或列號無效時結束)：\n");
scanf("%d%d",&x, &y);
printf("請輸入特殊元的值\n");
scanf(inFORMAT, &d);
valid=PutElem(&M,d,x,y,equal);
}
printf("原矩陣=\n");
MatrixPrint(M, printdata);
MatrixTranspose(&M,M);
printf("轉置後矩陣=\n");
MatrixPrint(M, printdata);
printf("請輸入要讀取的單元的行號和列號：\n");
scanf("%d%d",&i,&j);
if(GetElem(M,&d,i,j))
{
printf("M[%d][%d]=",i,j);
printf(outFORMAT, d);
printf("\n");
}
else
printf("Invalid.\n");
MatrixPrint(M, printdata);
printf("Copy M to N.\n");
MatrixCopy(&N,M);
if(MatrixAdd(&M,M,N, add, equal))
{
printf("M+N=\n");
MatrixPrint(M, printdata);
}
MatrixDestroy(M);
}
E. 三元組表示稀疏矩陣是什麼
三元組表示稀疏矩陣是行列形式。為了方便某些矩陣運算，在按行優先存儲的三元組表中，加入一個行表來記錄稀疏矩陣中每行的非零元素在三元組表中的起始位置。
在矩陣中，若數值為0的元素數目遠遠多於非0元素的數目，並且非0元素分布沒有規律時，則稱該矩陣為稀疏矩陣；與之相反，若非0元素數目佔大多數時，則稱該矩陣為稠密矩陣。定義非零元素的總數比上矩陣所有元素的總數為矩陣的稠密度。
優點
稀疏矩陣的計算速度更快，因為 MATLAB 只對非零元素進行操作，這是稀疏矩陣的一個突出的優點。
假設矩陣 A,B 中的矩陣一樣，計算 2*A 需要一百萬次的浮點運算，而計算 2*B 只需要 2000 次浮點運算。
因為 MATLAB 不能自動創建稀疏矩陣，所以要用特殊的命令來得到稀疏矩陣。算術和邏輯運算都適用於稀疏矩陣。
對於一個用二維數組存儲的稀疏矩陣 Amn ，如果假設存儲每個數組元素需要 L 個位元組，那麼存儲整個矩陣需要 m*n*L 個位元組。但是，這些存儲空間的大部分存放的是 0 元素，從而造成大量的空間浪費。為了節省存儲空間，可以只存儲其中的非 0 元素。
F. c++三元組的存儲及轉置
這個應該比較完美了。不過一些字元輸入規則沒有強制限制。你自己改下吧。
代碼如下：
/* 稀疏矩陣乘法，三元組法實現*/
#include <iostream>
#include <iomanip>
using namespace std;
const int MAX_SIZE = 100; // 矩陣中非零元素的最多個數
const int LEN = 3; // 矩陣中元素的對齊長度
// 當矩陣元素因為位數導致不能對齊的時候調整該值
struct Node
{
int nRow,nCol; // 三元組的行、列號
int nVal; // 元素的值
};
struct SparMatrix
{
int nRows,nCols; // 矩陣的行、列數
int nTerms; // 矩陣的非零元個數
struct Node arrayData[MAX_SIZE]; // 存放矩陣非零元素的三元組數組
void PrintMatrix(); // 輸出矩陣
int GetElement(int m ,int n); // 獲得矩陣對應的元素
void PrintInit(); // 矩陣的輸入初始化
void AddElement(int m,int n, int nVal); // 增加非零元素
};
// 矩陣乘法函數(*new)記得釋放內存。
SparMatrix* MatrixMulti(SparMatrix* pM1,SparMatrix* pM2);
void main()
{
SparMatrix matrix1;
cout << "The 1st matrix:" << endl;
matrix1.PrintInit();
SparMatrix matrix2;
cout << "The 2nd matrix:" << endl;
matrix2.PrintInit();
cout << "Multiplication:" << endl;
matrix1.PrintMatrix();
cout << "*" << endl;
matrix2.PrintMatrix();
cout << "=" << endl;
SparMatrix* pMatrixPro;
pMatrixPro = MatrixMulti(&matrix1,&matrix2);
if (pMatrixPro == NULL)
{
cout << "Error!" << endl;
}
else
{
pMatrixPro->PrintMatrix();
}
if (pMatrixPro != NULL)
{
delete pMatrixPro;
pMatrixPro = NULL;
}
}
void SparMatrix::PrintMatrix()
{
// cout << "Print Matrix:" << endl;
for (int m = 1 ; m <= nRows; m++)
{
cout << "|" << setw(LEN);
for (int n = 1 ; n <= nCols; n++)
{
cout << GetElement(m,n) ;
if (n == nCols)
{
break;
}
cout << "," << setw(LEN);
}
cout << "|" << endl ;
}
}
int SparMatrix::GetElement(int m ,int n)
{
for (int i = 0 ; i < nTerms; i++)
{
if (arrayData[i].nRow == m && arrayData[i].nCol == n)
{
return arrayData[i].nVal;
}
}
return 0;
}
void SparMatrix::AddElement(int m,int n, int nVal)
{
Node element = {m,n,nVal};
arrayData[nTerms] = element;
nTerms++;
}
void SparMatrix::PrintInit()
{
nTerms = 0;
int m , n;
while(1)
{
cout << "Plz input the row and column num, using space to separate them:" << endl;
cin >> m >> n;
if (m > 0 && n > 0)
{
break;
}
cout << "The num is wrong. Plz input again." << endl;
cin.clear();
cin.sync();
}
nRows = m;
nCols = n;
cout << "Matrix: ( " << m << " , " << n << " )" << endl;
int num = 0;
int nVal = 0;
char chTmp[10] = {0};
while (1)
{
cout << "Plz input the " << num+1 << " element. * to end:" << endl;
cin >> chTmp;
if (*chTmp == '*')
{
cout << "Over" << endl;
break;
}
else
{
nVal = atoi(chTmp);
}
while(1)
{
cout << "Then input the row and colum of this element, using space to separate them:" << endl;
cin >> m >> n;
if (m > 0 && n > 0 && m <= nRows && n <= nCols)
{
break;
}
cout << "The num is wrong. Plz input again." << endl;
cin.clear();
cin.sync();
}
AddElement(m,n,nVal);
}
}
SparMatrix* MatrixMulti(SparMatrix* pM1,SparMatrix* pM2)
{
if (pM1->nCols != pM2->nRows)
{
return NULL;
}
SparMatrix* pro = new SparMatrix;
pro->nTerms = 0;
pro->nRows = pM1->nRows;
pro->nCols = pM2->nCols;
for (int m = 1 ; m <= pM1->nRows; m++)
{
for (int n = 1 ; n <= pM2->nCols; n++)
{
int nVol = 0;
for (int p = 1; p <= pM1->nCols; p++)
{
int nPro = pM1->GetElement(m,p)*pM2->GetElement(p,n);
nVol += nPro;
}
if (nVol != 0)
{
pro->AddElement(m,n,nVol);
}
}
}
return pro;
}
G. 三元組表頭占不佔存儲空間
你好，三元組表頭也是占存儲空間的，一般會佔到1~2個位元組。
以後您如果再遇到類似的問題，可以按照下面的思路去解決：
1、發現問題:往往生活在世界中，時時刻刻都處在這各種各樣的矛盾中，當某些矛盾放映到意識中時,個體才發現他是個問題，並要求設法去解決它。這就是發現問題的階段。從問題的解決的階段性看，這是第一階段，是解決問題的前提。
2、分析問題:要解決所發現的問題，必須明確問題的性質，也就是弄清楚有哪些矛盾、哪些矛盾方面，他們之間有什麼關系,以明確所要解決的問題要達到什麼結果，所必須具備的條件、其間的關系和已具有哪些條件,從而找出重要的矛盾、關鍵矛盾之所在。
3、提出假設:在分析問題的基礎上，提出解決問題的假設,即可採用的解決方案,其中包括採取什麼原則和具體的途徑和方法，但所有這些往往不是簡單現成的，而且有多種多樣的可能。但提出假設是問題解決的關鍵階段，正確的假設引導問題順利得到解決,不正確不恰當的假設則使問題的解決走彎路或導向歧途。
4、校驗假設:假設只是提出n種可能解決方案,還不能保證問題必定能獲得解決，所以問題解決的最後一步是對假設進行檢驗。不論哪種檢驗如果未能獲得預期結果，必須重新另提出假設再進行檢驗，直至獲得正確結果，問題才算解決。
H. 數據結構問題， 有一個100*90的稀疏矩陣，非零元素有10個，設元素為整型，每個整型數
每個元素要用行號，列號，元素值來表示，在用三元組表示稀疏矩陣，還要三個成員來記住，矩陣的行數列數，總的元素數，所以所需的位元組數是10*（1+1+1）*2+3*2=66。
模塊即是一個.c 文件和一個.h 文件的結合，頭文件(.h)中是對於該模塊介面的聲明；這一條概括了模塊化的實現方法和實質：將一個功能模塊的代碼單獨編寫成一個.c文件，把該模塊的介面函數放在.h文件中。
(8)三元組存儲兩個位元組擴展閱讀：
數據元素的機內表示： 用二進制位（bit）的位串表示數據元素。通常稱這種位串為節點（node）。當數據元素有若干個數據項組成時，位串中與各個數據項對應的子位串稱為數據域（data field）。因此，節點是數據元素的機內表示（或機內映像）。
關系的機內表示（映像方法）：數據元素之間的關系的機內表示可以分為順序映像和非順序映像，常用兩種存儲結構：順序存儲結構和鏈式存儲結構。順序映像藉助元素在存儲器中的相對位置來表示數據元素之間的邏輯關系。非順序映像藉助指示元素存儲位置的指針來表示數據元素之間的邏輯關系。
I. 數據結構的問題！一個100x90的整型稀疏矩陣有10個非0元素，每個整型數佔2個位元組，則用三元組表
一個非零元用(i,j, num)表示。 則 一個非零元用6個位元組， 10個就是60個位元組。