【icoding 数组与广义表】习题

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;

在三元组中，i 和 j 从 1 开始计数，与数学中矩阵元素的编号一致
矩阵加法函数的原型为：

bool add_matrix(const TSMatrix *pM, const TSMatrix *pN, TSMatrix *pQ);

pM, pN, pQ 分别指向三个矩阵，当 pM 和 pN 两个矩阵不可加时，函数返回 false，否则函数返回 true，且 pQ 指向两个矩阵的和。
答案代码：

#include "tsmatrix.h"
#include <stdio.h>
#include <stdlib.h>

bool add_matrix(const TSMatrix* pM, const TSMatrix* pN, TSMatrix* pQ)
{
    if (pM->m != pN->m || pM->n != pN->n) {
        return false;
    }
    int a = 0, b = 0, c = 0;
    pQ->len = 0;
    pQ->m == pM->m;
    pQ->n == pM->n;
    while (a < pM->len && b < pN->len && c < MAXSIZE) {
        if (pM->data[a].i < pN->data[b].i) {
            pQ->data[c].i = pM->data[a].i;
            pQ->data[c].j = pM->data[a].j;
            pQ->data[c].e = pM->data[a].e;
            a++;
            c++;
            pQ->len++;
        } else if (pM->data[a].i == pN->data[b].i) {
            if (pM->data[a].j > pN->data[b].j) {
                pQ->data[c].i = pN->data[b].i;
                pQ->data[c].j = pN->data[b].j;
                pQ->data[c].e = pN->data[b].e;
                b++;
                c++;
                pQ->len++;
            } else if (pM->data[a].j == pN->data[b].j) {
                if (pM->data[a].e == -pN->data[b].e) {
                    a++;
                    b++;
                } else {
                    pQ->data[c].i = pM->data[a].i;
                    pQ->data[c].j = pM->data[a].j;
                    pQ->data[c].e = pM->data[a].e + pN->data[b].e;
                    a++;
                    b++;
                    c++;
                    pQ->len++;
                }
            } else if (pM->data[a].j < pN->data[b].j) {
                pQ->data[c].i = pM->data[a].i;
                pQ->data[c].j = pM->data[a].j;
                pQ->data[c].e = pM->data[a].e;
                a++;
                c++;
                pQ->len++;
            }
        } else if (pM->data[a].i > pN->data[b].i) {
            pQ->data[c].i = pN->data[b].i;
            pQ->data[c].j = pN->data[b].j;
            pQ->data[c].e = pN->data[b].e;
            b++;
            c++;
            pQ->len++;
        }
    }
    if (a < pM->len) {
        while (a < pM->len && c < MAXSIZE) {
            pQ->data[c].i = pM->data[a].i;
            pQ->data[c].j = pM->data[a].j;
            pQ->data[c].e = pM->data[a].e;
            pQ->len++;
            a++;
            c++;
        }

    } else if (b < pN->len) {
        while (b < pN->len && c < MAXSIZE) {
            pQ->data[c].i = pN->data[b].i;
            pQ->data[c].j = pN->data[b].j;
            pQ->data[c].e = pN->data[b].e;
            pQ->len++;
            b++;
            c++;
        }
    }
    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 元素的个数。

答案代码：

#include "crosslist.h"
#include <stdio.h>
#include <stdlib.h>

int init_cross_list(PCrossList L, const ElemType* A, int m, int n)
{
    int num = 0, i, j, k;
    OLNode* p;
    OLNode* q;
	//初始化行列数
    L->rows = m;
    L->cols = n;
	//申请内存空间溢出
    if (!(L->rowhead = (OLink*)malloc(m * sizeof(OLink))))
        return 0;
    if (!(L->colhead = (OLink*)malloc(n * sizeof(OLink))))
        return 0;
    //头指针清空
    for (k = 0; k < m; k++)
        L->rowhead[k] = NULL;
    for (k = 0; k < n; k++)
        L->colhead[k] = NULL;
    //只存储非零项
    for (k = 0; k < m * n; k++) {
        if (A[k] == 0) {
            continue;
        } else {
            p = (OLink)malloc(sizeof(OLNode));
            p->row = k / n;
            p->col = k % n;
            p->value = A[k];
            p->right = NULL;
            p->down = NULL;
			//标准的十字链表插入操作
            i = p->row;
            if (L->rowhead[i] == NULL) {
                L->rowhead[i] = p;
            } else {
                for (q = L->rowhead[i]; q->right && q->right->col < p->col; q = q->right)
                	p->right = q->right;
                	q->right = p;
            }

            j = p->col;
            if (L->colhead[j] == NULL) {
                L->colhead[j] = p;
            } else {
                for (q = L->colhead[j]; q->down && q->down->row < p->row; q = q->down)
                	p->down = q->down;
                	q->down = p;
            }
            num++;
        }
    }
    L->nums = num;
    return num;
}

2）实现十字链表的删除操作：

 int del_cross_list(PCrossList L, ElemType k);

其中 L 指向 要处理的 CrossList 结构，k 为要删除的元素；
del_cross_list 函数删除十字链表中所有值为 k 的结点，并返回删除结点的个数。
答案代码：

int del_cross_list(PCrossList L, ElemType k)
{
    int i = 0, j = 0, t = 0;

    OLink p = NULL; //我们要操作的节点
    OLink templeft = NULL; //操作节点左边的节点
    OLink tempup = NULL; //操作节点上边的节点

    for (; i < L->rows; i++) { //按行检索
        if (L->rowhead[i] == NULL) { //如果这一行为空，则直接跳到下一行
            continue;
        }

        for (p = L->rowhead[i]; p != NULL; p = p->right) { //每行里面从左到右依次检索
            if (p->value == k) { //若当前节点就是要删除的节点
                for (templeft = L->rowhead[i]; templeft->right != NULL && templeft->right->col < p->col; templeft = templeft->right)
                    ;
                for (tempup = L->colhead[p->col]; tempup->down != NULL && tempup->down->row < p->row; tempup = tempup->down)
                    ;

                //找到他左边和上边的节点并记录
                if (templeft == p) { //左边没有节点
                    if (tempup == p) { //并且上边也没有节点
                        L->rowhead[i] = p->right;
                        L->colhead[p->col] = p->down;
                        free(p);
                    } else { //上边有节点
                        L->rowhead[i] = p->right;
                        tempup->down = p->down;
                        free(p);
                    }
                } else { //左边有节点
                    if (tempup == p) { //上边没有节点
                        templeft->right = p->right;
                        L->colhead[p->col] = p->down;
                        free(p);
                    } else { //上边有节点
                        templeft->right = p->right;
                        tempup->down = p->down;
                        free(p);
                    }
                }
                t++;
                L->nums--;
            }
        }
    }
    return t;
}