稀疏矩阵的转置运算(三元组顺序表)

三元组顺序表

#define MAXSIZE 1000//稀疏矩阵非零元素个数
typedef  int ElementType;//稀疏矩阵元素类型

typedef struct
{
    int row;
    int col;
    ElementType value;
}Triple;

typedef struct
{
    int rows;
    int cols;
    int nums;//非零元素个数
    Triple data[MAXSIZE];
}TSMatrix;//Triple Sequence Matrix

按列序递增_1

void TransposeSMatrix_1(TSMatrix A, TSMatrix* B)
{
    int i;
    int j;
    int k;
    B->rows = A.cols;
    B->cols = A.rows;
    B->nums = A.nums;

    if (B->nums > 0)
    {
        j = 0;
        for (k = 1; k <= A.cols; k++)
        {//按列序递增
            for (i = 0; i <= A.nums; i++)
            {//遍历所有非零元素，找到对应下标
                if (A.data[i].col == k)
                {
                    B->data[j].row = A.data[i].col;
                    B->data[j].col = A.data[i].row;
                    B->data[j].value = A.data[i].value;
                    j++;
                }
            }
        }
    }
}

按列序递增_2(非零元素所在列全部排序完成直接结束)

void TransposeSMatrix_2(TSMatrix A, TSMatrix* B)
{
    int i;
    int j;
    int k;
    B->rows = A.cols;
    B->cols = A.rows;
    B->nums = A.nums;

    if (B->nums > 0)
    {
        j = 0;
        for (k = 1; k <= A.cols; k++)
        {//按列序递增
            for (i = 0; i <= A.nums; i++)
            {//遍历所有非零元素，找到对应下标
                if (A.data[i].col == k)
                {
                    B->data[j].row = A.data[i].col;
                    B->data[j].col = A.data[i].row;
                    B->data[j].value = A.data[i].value;
                    j++;
                    if (j == A.nums)
                    {//非零元素所在的列全部排序完成
                        return;
                    }
                }
            }
        }
    }
}

按列序递增_3(每次在非零元素中寻找列值最小的元素)

void TransposeSMatrix_3(TSMatrix A, TSMatrix* B)
{
    int i;
    int j;
    int min;
    B->rows = A.cols;
    B->cols = A.rows;
    B->nums = A.nums;

    for (i = 0; i < A.nums; i++)
    {
        min = 0;
        for (j = 1; j < A.nums; j++)
        {//记录最小列值的下标
            if (A.data[j].col < A.data[min].col)
            {
                min = j;
            }
        }
        B->data[i].row = A.data[min].col;
        B->data[i].col = A.data[min].row;
        B->data[i].value = A.data[min].value;
        A.data[min].col = A.cols + 1;//考察完的列值标记为最大列值+1，即下次不再考虑
    }
}

一次定位快速转置算法

void FastTransposeSMatrix(SMatrix A, SMatrix* B)//一次定位快速转置
{
    int i;
    int j;
    int num[MAXSIZE] = { 0 };//每列非零元素个数
    int position[MAXSIZE] = { 0 };//转置前非零元素某列 对应的 转置后的矩阵非零数组中某行的 起始位置
    B->rows = A.cols;
    B->cols = A.rows;
    B->nums = A.nums;

    for (i = 0; i < A.nums; i++)
    {// num数组下标就是转置后的行号; num 数组元素代表转置后该行有几个非零元素
        num[A.data[i].col]++;
    }

    position[1] = 1;
    for (i = 2; i < A.cols; i++)
    {//本行元素在非零矩阵数组中起始位置 = 前一行非零元素起始位置 + 前一行非零元素个数
        position[i] = position[i - 1] + num[i - 1];
    }

    for (i = 0; i < A.nums; i++)
    {
        j = position[A.data[i].col];//通过查表 position 数组来找转置对应位置
        B->data[j].row = A.data[i].col;
        B->data[j].col = A.data[i].row;
        B->data[j].value = A.data[i].value;
        position[A.data[i].col]++;//修改 position[A.data[i].col] ，将其指向该行下一个元素的存储位置
    }
}