矩阵转置的一般算法

首先定义矩阵中存放元素的结构体

struct Triple
{
    int i, j;
    datatype e;
};

然后定义矩阵M, M中包含行数，列数，矩阵中元素个数，以及存放矩阵中每一个元素特征的一个数组

struct TripleTable
{
    Triple data[MAX_SIZE];
    int mu, nu, tu; //行数，列数，非零元素的个数
};

矩阵M转置为T的一般算法思路如下：

　　首先建立矩阵，然后遍历矩阵M中的所有元素

　　第一次扫描：

　　　　将M中所有列号为1的元素赋值到T.data中

　　第二次扫描：

　　　　将M中所有列号为2的元素赋值到T.data中

　　以此类推，知道M中的所有元素都放到T中去

具体代码如下：

#define MAX_SIZE 10000
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <malloc.h>
/*
矩阵的转置算法
    基本思想：
        对M.data从头至尾进行扫描
        第一次扫描：
            将M.data中所有列号为1的元素赋值到T.data中
        第二次扫描：
            将M.data红所有列号为2的元素赋值到T.data中
        以此类推，直至将M.data中的所有元素赋值到T.data中
*/
typedef int datatype;
struct Triple
{
    int i, j;
    datatype e;
};
struct TripleTable
{
    Triple data[MAX_SIZE];
    int mu, nu, tu; //行数，列数，非零元素的个数
};
void TransposeSMatrix(struct TripleTable &M, struct TripleTable &T)
{
    int q = 0;
    T.mu = M.nu;
    T.nu = M.mu;
    T.tu = M.tu;
    if(T.tu)
    {
        for(int col = 1; col <= M.nu; ++col)
        {
            for(int p = 1; p <= M.tu; ++p)
            {
                if(M.data[p].j == col)
                {
                    T.data[q].i = M.data[p].j;
                    T.data[q].j = M.data[p].i;
                    T.data[q].e = M.data[p].e;
                    ++q;
                }
            }
        }
    }
}
void Init(struct TripleTable &M)
{
    M.mu = 7; M.nu = 6; M.tu = 8;
    M.data[1].i = 1; M.data[1].j = 2; M.data[1].e = 12;
    M.data[2].i = 1; M.data[2].j = 3; M.data[2].e = 9;
    M.data[3].i = 3; M.data[3].j = 1; M.data[3].e = -3;
    M.data[4].i = 3; M.data[4].j = 6; M.data[4].e = 14;
    M.data[5].i = 4; M.data[5].j = 3; M.data[5].e = 24;
    M.data[6].i = 5; M.data[6].j = 2; M.data[6].e = 18;
    M.data[7].i = 6; M.data[7].j = 1; M.data[7].e = 15;
    M.data[8].i = 6; M.data[8].j = 4; M.data[8].e = -7;
}
void Print(struct TripleTable M)
{
    for(int a = 1; a <= M.mu; a++)
    {
        for(int b = 1; b <= M.nu; b++)
        {
            int flag = 1;
            for(int k = 1; k <= M.tu; k++)
            {
                if(M.data[k].i == a && M.data[k].j == b)
                {
                    printf("%8d", M.    data[k].e);
                    flag = 0;
                    break;
                }
            }
            if(flag)
                printf("       0");
        }
        printf("
");
    }
    printf("
");
}
int main()
{
    struct TripleTable M, T;
    Init(M);
    for(int i = 1; i <= M.tu; i++)
    {
        printf("%d %d %d 
", M.data[i].i, M.data[i].j, M.data[i].e);
    }
    Print(M);
    system("pause");
    TransposeSMatrix(M, T);
    Print(T);
    return 0;
}