十字链表存储稀疏矩阵

/*广义表的定义 

typedef struct GNode *GList;
struct GNode{
    int Tag; //标志域：0表示结点是单元素，1表示结点是广义表 
    union{  //子表指针域SubList与单元素数据域Data复用，即共用存储空间 
        ElementTtype Data;
        GList SubList;
    }URegion;
    GList Next; //指向后继结点  
};
*/ 

#include 
#include 
#define MAX 100
/*
  用十字链表存储稀疏矩阵
  设计要点：
        1.用数组存储head，数组中的第一个元素
         col：矩阵列数，row：矩阵行数，value：非零元素的值
        2，行和列均用循环链表实现
        3.实现了三个方法：初始化，插入，打印 
*/ 

/* 稀疏矩阵

A= 18 0 0
   0 27 0
   0 0 0
   23 -1 0 

*/ 

//定义结构
typedef struct SparseMatrix{
    struct SparseMatrix *Down;
    struct SparseMatrix *Right;
    union{
        struct{
            int row;
            int col;
            int value;
        };
        struct SparseMatrix *Next;
    }URegion;
}SparseMatrix; 

//初始化一个稀疏矩阵
void smInitialize(SparseMatrix *smArray[],int row,int col);
//插入一个非零元素，已有则替换
void smInsertTerm(SparseMatrix *mySM[],int row,int col,int value);
//给出矩阵，循环打印非零元素
void smPrint(SparseMatrix *mySM);
//查找某一位置是否是非零元素，是则返回1，否则返回0
int smFindTerm(SparseMatrix *mySm[],int row,int col);
//删除某一位置的非零元素，删除返回1，否则返回0
int smDeleteTerm(SparseMatrix *mySM[],int row,int col);

int main(int argc, char *argv[])   
{  
    SparseMatrix *term00[MAX]={NULL};  
    smInitialize(term00,4,3);  

    smInsertTerm(term00,1,1,18);  
    smInsertTerm(term00,2,2,27);  
    smInsertTerm(term00,4,3,24);  
    smInsertTerm(term00,4,1,23);  
    smInsertTerm(term00,4,2,-1);  
    smInsertTerm(term00,1,2,20 ); 
    smPrint(term00[0]);

    return 0;  
} 

void smInitialize(SparseMatrix *smArray[],int row,int col)  
{  
    SparseMatrix *term00=(SparseMatrix*)malloc(sizeof(SparseMatrix));  
    term00->URegion.row=row;  
    term00->URegion.col=col;  
    term00->URegion.value=0;  
    term00->Right=term00;  
    term00->Right=NULL;  
    smArray[0]=term00;  
    //初始化head结构   
    int headNum=row>col?row:col;  
//  if(headNum>MAX)  
//     throw;  
    for(int i=1;i<=headNum;i++){  
        smArray[i]=(SparseMatrix*)malloc(sizeof(SparseMatrix));;  
        if(i==1){  
            term00->Right=smArray[i];  
        }else{  
            smArray[i-1]->URegion.Next=smArray[i];  
        }  
        smArray[i]->Down=smArray[i];//每列是循环列表   
        smArray[i]->Right=smArray[i];//每行是循环列表   
    }  

    smArray[headNum]->URegion.Next=smArray[0];//head与term00形成循环链表   
}  
void smInsertTerm(SparseMatrix* mySM[],int row,int col,int value)  
{  
//  if(mySM[0]->URegion.rowURegion.col
//      throw ;  
    //非零节点行，列，值   
    int repeatFlag=0;  
    SparseMatrix* term=(SparseMatrix*)malloc(sizeof(SparseMatrix));  
    term->URegion.col=col;  
    term->URegion.row=row;  
    term->URegion.value=value;   
    //非零节点链接到链表中   
    SparseMatrix* rowP=mySM[row]->Right;  
    SparseMatrix* rowLastP=mySM[row];  
    SparseMatrix* colP=mySM[col]->Down;  
    SparseMatrix* colLastP=mySM[col];  
    while(rowP!=mySM[row] && rowP->URegion.col<=col){  
        rowLastP=rowP;  
        if(rowP->URegion.col!=col){  
            rowP=rowP->Right;  
        }else{  
            repeatFlag=1;  
        }  
    }   

    //如果节点已有， 指向已有的下一个  
    if(repeatFlag){  
        term->Right=rowP->Right;  
    }else{  
        term->Right=rowP;  
    }  
    rowLastP->Right=term;  


    while(colP!=mySM[col]  && colP->URegion.rowDown;  
    }  
    //如果节点已有， 指向已有的下一个   
    if(repeatFlag){  
        term->Down=colP->Down;  
    }else{  
        term->Down=colP;  
    }  
    colLastP->Down=term;  
    //删除重复的   
    if(repeatFlag)   
    {  
        free(colP);  
    }  

    mySM[0]->URegion.value+=1;   
}  

void smPrint(SparseMatrix* mySM){  
    SparseMatrix *head;  
    if(mySM){  
        head=mySM->Right;  
    }else{  
        return;  
    }  
    SparseMatrix *colP=head->Right;  
    SparseMatrix* headP=head;  

    while(headP!=mySM){  
        while(colP!=headP){  
            printf("%d,%d,%d||%d\n",colP->URegion.value,colP->URegion.row,colP->URegion.col,mySM->URegion.value);  
            colP=colP->Right;  
        }  
        headP=headP->URegion.Next;  
        colP=headP->Right;  
    }  
}