十字链表的c语言实现

在学习数据结构时对十字链表突然起了兴趣，于是便去找了下资源，接合写出了这么个东西

有错误希望能指出，不胜感激！

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

typedef int ElemType;

typedef struct OLNode
{
    int i, j;
    ElemType e;
    struct OLNode *right, *down;
} OLNode, *OLink, *QLink;

typedef struct
{
    OLink *rhead, *chead;
    int mu, nu, tu;
} Crosslist, CrossList;

void InitSMatrix(Crosslist *M)
{
    (*M).rhead = (*M).chead = NULL;
    (*M).mu = (*M).nu = (*M).tu = 0;
}

void DestroySMatrix(Crosslist *M)
{
    int i;
    OLNode *p, *q;
    for (i = 1; i <= (*M).mu; i++)
    {
        p = *((*M).rhead + i);
        while (p)
        {
            q = p;
            p = p->right;
            free(q);
        }
    }

    free((*M).rhead);
    free((*M).chead);
    (*M).rhead = (*M).chead = NULL;
    (*M).mu = (*M).nu = (*M).tu = 0;
}

void CreateSMatrix(Crosslist *M)
{
    int i, j, k, m, n, t;
    ElemType e;
    OLNode *p, *q;
    if ((*M).rhead != NULL)
        DestroySMatrix(M);
    printf("请输入稀疏矩阵的行数 列数 非零元素个数：");
    scanf("%d %d %d", &m, &n, &t);
    (*M).mu = m;
    (*M).nu = n;
    (*M).tu = t;

    (*M).rhead = (OLink *)malloc((m + 1) * sizeof(OLink));
    if ((*M).rhead == NULL)
    {
        exit(-1);
    }
    (*M).chead = (OLink *)malloc((n + 1) * sizeof(OLink));
    if ((*M).chead == NULL)
    {
        exit(-1);
    }
    for (k = 1; k <= m; k++)
        (*M).rhead[k] = NULL;
    for (k = 1; k <= m; k++)
        (*M).chead[k] = NULL;
    printf("请按任意次序输入%d个非零元的行 列 元素值:（空格）\n", (*M).tu);
    for (k = 0; k < t; k++)
    {
        scanf("%d %d %d", &i, &j, &e);
        p = (OLNode *)malloc(sizeof(OLNode));
        if (!p)
            exit(-1);
        p->i = i;
        p->j = j;
        p->e = e;
        if ((*M).rhead[i] == NULL || (*M).rhead[i]->j > j)
        {
            p->right = (*M).rhead[i];
            (*M).rhead[i] = p;
        }
        else
        {
            for (q = (*M).rhead[i]; q->right && q->right->j < j; q = q->right)
                ;
            p->right = q->right;
            q->right = p;
        }
        if ((*M).chead[j] == NULL || (*M).chead[j]->j > j)
        {
            p->down = (*M).chead[i];
            (*M).chead[j] = p;
        }
        else
        {
            for (q = (*M).chead[i]; q->down && q->down->i < i; q = q->down)
                ;
            p->down = q->down;
            q->down = p;
        }
    }
}

void PrintSMatrix(Crosslist M)
{
    int i, j;
    OLink p;
    printf("%d行%d列%d个非零元素\n", M.mu, M.nu, M.tu);
    if (M.mu == 0 && M.nu == 0 && M.tu == 0)
    {
        printf("empty\n");
        return;
    }
    printf("请输入选择(1.按行输出 2.按列输出): ");
    scanf("%d", &i);
    switch (i)
    {
    case 1:
        for (j = 1; j <= M.mu; j++)
        {
            p = M.rhead[j];
            while (p)
            {
                printf("%d行%d列值为%d\n", p->i, p->j, p->e);
                p = p->right;
            }
        }
        break;
    case 2:
        for (j = 1; j <= M.nu; j++)
        {
            p = M.chead[j];
            while (p)
            {
                printf("%d行%d列值为%d\n", p->i, p->j, p->e);
                p = p->down;
            }
        }
        break;
    }
}

void CopySMatrix(Crosslist M, Crosslist *T)
{
    int i;
    OLink p, q, q1, q2;

    if ((*T).rhead != NULL)
        DestroySMatrix(T);
    (*T).mu = M.mu;
    (*T).nu = M.nu;
    (*T).tu = M.tu;
    (*T).rhead = (OLink *)malloc((M.mu + 1) * sizeof(OLink));
    if ((*T).rhead == NULL)
        exit(-1);
    (*T).chead = (OLink *)malloc((M.nu + 1) * sizeof(OLink));
    if ((*T).chead == NULL)
        exit(-1);
    for (i = 1; i <= M.mu; i++)
        (*T).rhead[i] = NULL;
    for (i = 1; i <= M.nu; i++)
        (*T).chead[i] = NULL;

    for (i = 1; i <= M.mu; i++)
    {
        p = M.rhead[i];
        while (p)
        {
            q = (OLNode *)malloc(sizeof(OLNode));
            if (q == NULL)
                exit(-1);
            q->i = p->i;
            q->j = p->j;
            q->e = p->e;
            if ((*T).rhead[i] == NULL)
                (*T).rhead[i] = q1 = q;
            else
                q1 = q1->right = q;
            if ((*T).chead[q->j] == NULL)
            {
                (*T).chead[q->j] = q;
                q->down = NULL;
            }
            else
            {
                q2 = (*T).chead[q->j];
                while (q2->down != NULL)
                    q2 = q2->down;
                q2->down = q;
                q->down = NULL;
            }
            p = p->right;
        }
        q->right = NULL;
    }
}

int AddSMatrix(Crosslist M, Crosslist N, Crosslist *Q)
{
    int i, k;
    OLink p, pq, pm, pn;
    OLink *col;

    if (M.mu != N.mu || M.nu != N.nu)
    {
        printf("两个矩阵不是同类型的,不能相加\n");
        exit(-1);
    }

    (*Q).mu = M.mu;
    (*Q).nu = M.nu;
    (*Q).tu = 0;
    (*Q).rhead = (OLink *)malloc(((*Q).mu + 1) * sizeof(OLink));
    if (!(*Q).rhead)
        exit(-1);
    (*Q).chead = (OLink *)malloc(((*Q).nu + 1) * sizeof(OLink));
    if (!(*Q).chead)
        exit(-1);
    for (k = 1; k <= (*Q).mu; k++)
        (*Q).rhead[k] = NULL;
    for (k = 1; k <= (*Q).nu; k++)
        (*Q).chead[k] = NULL;
    col = (OLink *)malloc(((*Q).nu + 1) * sizeof(OLink));

    if (!col)
        exit(-1);
    for (k = 1; k <= (*Q).nu; k++)
        col[k] = NULL;
    for (i = 1; i <= M.mu; i++)
    {
        pm = M.rhead[i];
        pn = N.rhead[i];
        while (pm && pn)
        {
            if (pm->j < pn->j)
            {
                p = (OLink)malloc(sizeof(OLNode));
                if (!p)
                    exit(-1);
                (*Q).tu++;
                p->i = i;
                p->j = pm->j;
                p->e = pm->e;
                p->right = NULL;
                pm = pm->right;
            }
            else if (pm->j > pn->j)
            {
                p = (OLink)malloc(sizeof(OLNode));
                if (!p)
                    exit(-1);
                (*Q).tu++;
                p->i = i;
                p->j = pn->j;
                p->e = pn->e;
                p->right = NULL;
                pn = pn->right;
            }
            else if (pm->e + pn->e)
            {
                p = (OLink)malloc(sizeof(OLNode));
                if (!p)
                    exit(-1);
                (*Q).tu++;
                p->i = i;
                p->j = pn->j;
                p->e = pn->e + pm->e;
                p->right = NULL;
                pn = pn->right;
                pm = pm->right;
            }
            else
            {
                pm = pm->right;
                pn = pn->right;
                continue;
            }

            if ((*Q).rhead[i] == NULL)
                (*Q).rhead[i] = pq = p;
            else
            {
                pq->right = p;
                pq = pq->right;
            }

            if ((*Q).chead[p->j] == NULL)
                (*Q).chead[p->j] = col[p->j] = p;
            else
            {
                col[p->j]->down = p;
                col[p->j] = col[p->j]->down;
            }
        }
        while (pm)
        {
            p = (OLink)malloc(sizeof(OLNode));
            if (!p)
                exit(-1);
            (*Q).tu++; // 非零元素数加1
            p->i = i;  // 给结点赋值
            p->j = pm->j;
            p->e = pm->e;
            p->right = NULL;
            pm = pm->right;            // pm指针向右移
            if ((*Q).rhead[i] == NULL) // p为该行的第1个结点
                // p插在该行的表头且pq指向p(该行的最后一个结点)
                (*Q).rhead[i] = pq = p;
            else // 插在pq所指结点之后
            {
                pq->right = p;  // 完成行插入
                pq = pq->right; // pq指向该行的最后一个结点
            }
            if ((*Q).chead[p->j] == NULL) // p为该列的第1个结点
                                          // p插在该列的表头且col[p->j]指向p
                (*Q).chead[p->j] = col[p->j] = p;
            else // 插在col[p->j]所指结点之后
            {
                col[p->j]->down = p; // 完成列插入
                // col[p->j]指向该列的最后一个结点
                col[p->j] = col[p->j]->down;
            }
        }
        while (pn) // 将矩阵N该行的剩余元素插入矩阵Q
        {
            p = (OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点
            if (!p)
                exit(0);
            (*Q).tu++; // 非零元素数加1
            p->i = i;  // 给结点赋值
            p->j = pn->j;
            p->e = pn->e;
            p->right = NULL;
            pn = pn->right;            // pm指针向右移
            if ((*Q).rhead[i] == NULL) // p为该行的第1个结点
                // p插在该行的表头且pq指向p(该行的最后一个结点)
                (*Q).rhead[i] = pq = p;
            else // 插在pq所指结点之后
            {
                pq->right = p;  // 完成行插入
                pq = pq->right; // pq指向该行的最后一个结点
            }
            if ((*Q).chead[p->j] == NULL) // p为该列的第1个结点
                // p插在该列的表头且col[p->j]指向p
                (*Q).chead[p->j] = col[p->j] = p;
            else // 插在col[p->j]所指结点之后
            {
                col[p->j]->down = p; // 完成列插入
                // col[p->j]指向该列的最后一个结点
                col[p->j] = col[p->j]->down;
            }
        }
    }
    for (k = 1; k <= (*Q).nu; k++)
        if (col[k])
            col[k]->down = NULL;
    free(col);
}

int SubtSMatrix(Crosslist M, Crosslist N, Crosslist *Q)
{
    int i, k;
    QLink p, pq, pm, pn;
    QLink *col;

    if (M.mu != N.mu || M.nu != N.nu)
    {
        printf("两个矩阵不是同类型的,不能相加\n");
        exit(-1);
    }

    (*Q).mu = M.mu;
    (*Q).nu = M.nu;
    (*Q).tu = 0;
    (*Q).rhead = (QLink *)malloc(((*Q).mu + 1) * sizeof(QLink));
    if (!(*Q).rhead)
        exit(-1);
    (*Q).chead = (QLink *)malloc(((*Q).nu + 1) * sizeof(QLink));
    if (!(*Q).chead)
        exit(-1);
    for (k = 1; k <= (*Q).mu; k++)
        (*Q).rhead[k] = NULL;
    for (k = 1; k <= (*Q).nu; k++)
        (*Q).rhead[k] = NULL;
    col = (QLink *)malloc(((*Q).nu + 1) * sizeof(QLink));
    if (!col)
        exit(-1);
    for (k = 1; k <= (*Q).nu; k++)
        col[k] = NULL;
    for (i = 1; i <= M.mu; i++)
    {
        pm = M.rhead[i];
        pn = N.rhead[i];
        while (pm && pn)
        {
            if (pm->j < pn->j)
            {
                p = (QLink)malloc(sizeof(OLNode));
                if (!p)
                {
                    exit(-1);
                }
                (*Q).tu++;
                p->i = i;
                p->j = pm->j;
                p->e = pm->e;
                p->right = NULL;
                pm = pm->right;
            }
            else if (pm->j > pn->j)
            {
                p = (QLink)malloc(sizeof(OLNode));
                if (!p)
                    exit(-1);
                (*Q).tu++;
                p->i = i;
                p->j = pn->j;
                p->e = -pn->e;
                p->right = NULL;
                pn = pn->right;
            }
            else if (pm->e - pn->e)
            {
                p = (QLink)malloc(sizeof(OLNode));
                if (!p)
                    exit(-1);
                (*Q).tu++;
                p->i = i;
                p->j = pn->j;
                p->e = pm->e - pn->e;
                p->right = NULL;
                pm = pm->right;
                pn = pn->right;
            }
            else
            {
                pm = pm->right;
                pn = pn->right;
                continue;
            }
            if ((*Q).rhead[i] == NULL)
                (*Q).rhead[i] = pq = p;
            else
            {
                pq->right = p;
                pq = pq->right;
            }

            if ((*Q).chead[p->j] == NULL)
                (*Q).chead[p->j] = col[p->j] = p;
            else
            {
                col[p->j]->down = p;
                col[p->j] = col[p->j]->down;
            }
        }

        while (pm)
        {
            p = (QLink)malloc(sizeof(OLNode));
            if (!p)
            {
                exit(-1);
            }
            (*Q).tu++;
            p->j = pm->j;
            p->i = i;
            p->e = pm->e;
            p->right = NULL;
            pm = pm->right;
            if ((*Q).rhead[i] == NULL)
                (*Q).rhead[i] = pq = p;
            else
            {
                pq->right = p;
                pq = pq->right;
            }

            if ((*Q).chead[p->j] == NULL)
                (*Q).chead[p->j] = col[p->j] = p;
            else
            {
                col[p->j]->down = p;
                col[p->j] = col[p->j]->down;
            }
        }
        while (pn)
        {
            p = (QLink)malloc(sizeof(OLNode));
            if (!p)
            {
                exit(-1);
            }
            (*Q).tu++;
            p->j = pn->j;
            p->i = i;
            p->e = -pn->e;
            p->right = NULL;
            pn = pn->right;
            if ((*Q).rhead[i] == NULL)
                (*Q).rhead[i] = pq = p;
            else
            {
                pq->right = p;
                pq = pq->right;
            }

            if ((*Q).chead[p->j] == NULL)
                (*Q).chead[p->j] = col[p->j] = p;
            else
            {
                col[p->j]->down = p;
                col[p->j] = col[p->j]->down;
            }
        }
    }

    for (k = 1; k <= (*Q).nu; k++)
    {
        if (col[k])
            col[k]->down = NULL;
    }
    free(col);
    return 1;
}

int MultSMatrix(CrossList M, CrossList N, CrossList *Q)
{
    int i, j, e;
    QLink q, p0, q0, q1, q2;

    (*Q).mu = M.mu;
    (*Q).nu = N.nu;
    (*Q).tu = 0;
    (*Q).rhead = (QLink*)malloc(((*Q).mu + 1)*sizeof(OLink));
    if(!(*Q).rhead)
        exit(-1);
    (*Q).chead = (QLink*)malloc(((*Q).nu + 1)*sizeof(OLink));
    if(!(*Q).chead)
        exit(-1);
    for(i = 1; i <= (*Q).mu; i++)
        (*Q).rhead[i] = NULL;
    for(i = 1; i <= (*Q).nu; i++)
        (*Q).chead[i] = NULL;

    for(i = 1; i <= (*Q).mu; i++)
    {
        for (j = 1; j <= (*Q).nu; j++)
        {
            p0 = M.rhead[i];
            q0 = N.chead[j];
            e = 0;
            while (p0 && q0)
            {
                if (q0->i < p0->j)
                    q0 = q0->down;
                else if (q0->i > p0->j)
                    p0 = p0->right;
                else
                {
                    e += p0->e * q0->e;
                    q0 = q0->down;
                    p0 = p0->right;
                }
            }
            if (e)
            {
                (*Q).tu++;
                q = (OLink)malloc(sizeof(OLNode));
                if (!q)
                    exit(-1);
                q->i = i;
                q->j = j;
                q->e = e;
                q->right = NULL;
                q->down = NULL;
                if(!(*Q).rhead[i])
                    (*Q).rhead[i] = q1 = q;
                else
                    q1 = q1->right = q;
                if(!(*Q).chead[j])
                    (*Q).chead[j] = q;
                else
                {
                    q2 = (*Q).chead[i];
                    while(q2->down)
                        q2 = q2->down;
                    q2->down = q;
                }
            }
        }
    }
    return 1;
}

int TransposeSMatrix(CrossList M, Crosslist *T)
{
    int u, i;
    QLink *head, p, q, r;

    if((*T).rhead)
        DestroySMatrix(T);

    CopySMatrix(M,T);
    u = (*T).mu;
    (*T).mu = (*T).nu;
    (*T).nu = u;
    head = (*T).rhead;
    (*T).rhead = (*T).chead;
    (*T).chead = head;

    for(u = 1; u <= (*T).mu; u++)
    {
        p = (*T).rhead[u];
        while(p)
        {
            q = p->down;
            i = p->i;
            p->i = p->j;
            p->j = i;
            r = p->down;
            p->down = p->right;
            p->right = r;
            p = q;
        }
    }
    return 1;
}
int main()
{
    Crosslist A, B, C;
    InitSMatrix(&A);
    InitSMatrix(&B);
    InitSMatrix(&C);
    printf("创建矩阵A：\n");
    CreateSMatrix(&A);
    PrintSMatrix(A);
    TransposeSMatrix(A,&C);
    PrintSMatrix(C);
    return 0;
}