icoding复习4 数组十字链表-优快云博客

本文介绍了如何实现稀疏矩阵的加法操作，使用三元组表示的稀疏矩阵进行加法运算，并检查矩阵是否可加。同时，详细阐述了十字链表的初始化和删除操作，包括如何从二维数组构建十字链表以及如何删除指定值的节点。这些数据结构和算法在处理大规模稀疏数据时非常有效。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

icoding 复习4

1. 矩阵加法
实现三元组表示的两个稀疏矩阵的加法。
#define MAXSIZE 100 //假设非零元个数的最大值为100
typedef struct {
int i,j;               //非零元的行下标和列下标，i 和 j 从 1 开始计数，与数学中矩阵元素的编号一致
ElemType e;               //非零元的值
}Triple;
typedef struct {
Triple data[MAXSIZE];   // 非零元三元组表
int m, n, len;       // 矩阵的行数、列数和非零元个数
}TSMatrix;
pM, pN, pQ 分别指向三个矩阵，当 pM 和 pN 两个矩阵不可加时，函数返回 false，
否则函数返回 true，且 pQ 指向两个矩阵的和。

#include "tsmatrix.h"
#include
#include

bool add_matrix(const TSMatrix* pM, const TSMatrix* pN, TSMatrix* pQ)
{
   if(pM->m != pN->m || pM->n != pN->n) return false;

   pQ->m = pM->m;
   pQ->n = pM->n;
   //记得检查结构体赋值!!
   int i, j, k = 0;
   for(i = 0, j = 0; i < pM->len && j < pN->len;){
       if(pM->data[i].i == pN->data[j].i){
           if(pM->data[i].j == pN->data[j].j){
               if(pM->data[i].e + pN->data[j].e){
                   pQ->data[k].e = pM->data[i].e + pN->data[j].e;
                   pQ->data[k].i = pM->data[i].i;
                   pQ->data[k].j = pM->data[i].j;
                   k++; i++; j++;
               }
               else{//这个else可以不要,前面的if里面的i++和j++可以提出来
                   i++; j++;
               }
           }
           else if(pM->data[i].j < pN->data[j].j){
               pQ->data[k].e = pM->data[i].e;
               pQ->data[k].i = pM->data[i].i;
               pQ->data[k].j = pM->data[i].j;
               k++; i++;
           }
           else{
               pQ->data[k].e = pN->data[j].e;
               pQ->data[k].i = pN->data[j].i;
               pQ->data[k].j = pN->data[j].j;
               k++; j++;
           }
       }
       else if(pM->data[i].i < pN->data[j].i){
           pQ->data[k].e = pM->data[i].e;
           pQ->data[k].i = pM->data[i].i;
           pQ->data[k].j = pM->data[i].j;
           k++; i++;
       }
       else{
           pQ->data[k].e = pN->data[j].e;
           pQ->data[k].i = pN->data[j].i;
           pQ->data[k].j = pN->data[j].j;
           k++; j++;
       }
   }
   while(i < pM->len){
       pQ->data[k].e = pM->data[i].e;
       pQ->data[k].i = pM->data[i].i;
       pQ->data[k].j = pM->data[i].j;
       k++; i++;
   }
   while(j < pN->len){
       pQ->data[k].e = pN->data[j].e;
       pQ->data[k].i = pN->data[j].i;
       pQ->data[k].j = pN->data[j].j;
       k++; j++;
   }
   pQ->len = k;
   return true;
}

2. 十字链表

typedef int ElemType;
// 非零元素结点结构
typedef struct OLNode
{
   int row,col;
   ElemType value;
   struct OLNode *right,*down;
}OLNode,*OLink;
// 十字链表结构
typedef struct
{
   OLink *rowhead,*colhead;
   int rows,cols,nums;
}CrossList, *PCrossList;

1）实现十字链表的初始化操作：
int init_cross_list(PCrossList L, const ElemType *A, int m, int n);
其中 L 指向 CrossList 结构，且各成员已被初始化为0；
A 为 ElemType 类型数组中第一个元素的地址，元素的个数为 m×n 个，按行优先存储
（即A[0] 为十字链表第1行第1列的元素；
A[1] 为第1行第2列的元素，A[n] 为第2行第1列的元素，A[n+1] 为第2行第2个元素）；

m 表示十字链表的行数，n 表示十字链表的列数。
init_cross_list 函数将 ElemType 数组中非0元素保存到十字链表中，函数返回非 0 元素的个数。

2）实现十字链表的删除操作：
int del_cross_list(PCrossList L, ElemType k);
其中 L 指向要处理的 CrossList 结构，k 为要删除的元素；
del_cross_list 函数删除十字链表中所有值为 k 的结点，并返回删除结点的个数。

掌握!!!!!!
int init_cross_list(PCrossList L, const ElemType* A, int m, int n)
{
int i, j, k = 0;
OLNode *p, *q;

L->cols = n;
L->rows = m;
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//下面这个是个很奇怪的数组可以认为是指针数组
if (!(L->rowhead = (OLink*)malloc(m * sizeof(OLink))))//也可以return 0;....icoding不会检测.....
;
if (!(L->colhead = (OLink*)malloc(n * sizeof(OLink))))
;

for (i = 0; i < m; i++)
L->rowhead[i] = NULL;

for (i = 0; i < n; i++)
L->colhead[i] = NULL;

for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
if (A[i * n + j] != 0) {
k++;
if (!(p = (OLNode*)malloc(sizeof(OLNode))))
;
p->col = j;
p->row = i;
p->value = A[i * n + j];
//!!!
if (L->rowhead[i] == NULL || L->rowhead[i]->col > j) {
p->right = L->rowhead[i]; //头插法
L->rowhead[i] = p;
} else {
q = L->rowhead[i];
while (q->right && q->right->col < j)
q = q->right;
p->right = q->right;
q->right = p;
}

if (L->colhead[j] == NULL || L->colhead[j]->row > i) {
p->down = L->colhead[j];
L->colhead[j] = p;
} else {
q = L->colhead[j];
while (q->down && q->down->row < i)
q = q->down;
p->down = q->down;
q->down = p;
}
}
}
}
L->nums = k;
return L->nums;
} //init

int del_cross_list(PCrossList L, ElemType k)
{
int num = 0;
int i, j;
OLNode *p, *q, *s;
OLNode *x, *y, *z;

for (i = 0; i < L->rows; i++) {
p = L->rowhead[i];
q = p;
while (p) {
if (p->value == k && p == q) {//第一个结点(不设头结点)
L->rowhead[i] = L->rowhead[i]->right;
free(p);
p = L->rowhead[i];
num++;
} else if (p->value == k) {
s = p;
q->right = p->right;
free(p);
p = q->right;
num++;
} else {
q = p;
p = p->right;
}
}
}
//下面的for可以不要,icoding根本不得检测纵向的链..........................................................
for (j = 0; j < L->cols; j++) {
x = L->colhead[j];
y = x;
while (x) {
if (x->value == k && x == y) {
L->colhead[j] = L->colhead[j]->down;
x = x->down;
free(y);
} else if (x->value == k) {
y->down = x->down;
z = x;
free(z);
} else {
y = x;
x = x->down;
}
}
}