数据结构之矩阵

最新推荐文章于 2024-08-02 11:17:36 发布
最新推荐文章于 2024-08-02 11:17:36 发布
阅读量676 收藏 7
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 矩阵 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AHuRui/article/details/124846052
版权

文章目录


矩阵乘

这里是数据结构个人学习的笔记记录，如有问题欢迎指正说明

一、矩阵乘的计算

矩阵乘这里定义了两个结构体，一个采用动态分配空间，数组长度不定，一个采用静态分配空间。

1.结构体的定义：

/*动态分配大小*/
typedef struct TwoDArray
{
    int row;
    int col;
    int** element;
}TwoDArray,*TwoDArrayPtr;

/*数组大小固定*/
typedef struct TwoDStaticArray{
	int row;
	int col;
	int element[ROW][COL];
} TwoDStaticArray, *TwoDStaticArrayPtr;

2.初始化

主要是动态分配内存空间。

/* 初始化 */
TwoDArrayPtr initTwoDArray(int paraRow,int paraCol)
{
    int i;
    TwoDArrayPtr resultPtr=(TwoDArrayPtr)malloc(sizeof(struct TwoDArray));
    resultPtr->row=paraRow;
    resultPtr->col=paraCol;
    resultPtr->element=(int**)malloc(paraRow*sizeof(int*));

    for(i=0;i<paraRow;i++)
    {
        resultPtr->element[i]=(int*)malloc(paraCol*sizeof(int));
    }
    return resultPtr;
}

3.数组初始化

通过生成随机数的方式将数组中存入数据。

void randomizeTwoDArray(TwoDArrayPtr paraPtr,int paraLowerBound,int paraUpperBound)
{
    int i,j;
    for(i=0;i<paraPtr->row;i++)
    {
        for(j=0;j<paraPtr->col;j++)
        {
            paraPtr->element[i][j]=rand()%(paraUpperBound-paraLowerBound)+paraLowerBound;
        }
    }
}

4.数组中数据打印

void printTwoDArray(TwoDArrayPtr paraPtr)
{
    int i,j;
    for(i=0;i<paraPtr->row;i++)
    {
        for(j=0;j<paraPtr->col;j++)
        {
            printf("%d, ",paraPtr->element[i][j]);
        }
        printf("\r\n");
    }
}

5.核心矩阵乘计算。

先要判断矩阵是否能相乘的问题。

TwoDArrayPtr matrixMultiply(TwoDArrayPtr paraPtr1,TwoDArrayPtr paraPtr2)
{
    int i,j,k,sum;
    if(paraPtr1->col!=paraPtr2->row)
    {
        printf("Matrices cannot be multiplied.\r\n");
        return NULL;
    }

    TwoDArrayPtr resultPtr=initTwoDArray(paraPtr1->row,paraPtr2->col);

    for(i=0;i<paraPtr1->row;i++)
    {
        for(j=0;j<paraPtr2->col;j++)
        {
            sum=0;
            for(k=0;k<paraPtr1->col;k++)
            {
                sum+=paraPtr1->element[i][k]*paraPtr2->element[k][j];
            }
            resultPtr->element[i][j]=sum;
            printf("sum=%d, ",sum);
        }
    }
    return resultPtr;
}

6.测试函数

void twoDArrayTest()
{
    TwoDArrayPtr tempPtr1,tempPtr2,tempPtr3;
    tempPtr1=initTwoDArray(3,2);
    randomizeTwoDArray(tempPtr1,1,5);
    printf("The first matrix:\r\n");
    printTwoDArray(tempPtr1);

    tempPtr2=initTwoDArray(2,4);
    randomizeTwoDArray(tempPtr2,4,9);
    printf("The second matrix:\r\n");
    printTwoDArray(tempPtr2);

    tempPtr3=matrixMultiply(tempPtr1,tempPtr2);
    printf("The result is:\r\n");
    printTwoDArray(tempPtr3);
}

TwoDStaticArrayPtr initTwoDStaticArray()
{
    int i,j;
    TwoDStaticArrayPtr resultPtr=(TwoDStaticArrayPtr)malloc(sizeof(struct TwoDStaticArray));
    resultPtr->row=ROW;
    resultPtr->col=COL;
    for(i=0;i<ROW;i++)
    {
        for(j=0;j<COL;j++)
        {
            resultPtr->element[i][j]=i*10+j;
            printf("(%d,%d):%d;\r\n",i,j,&(resultPtr->element[i][j]));
        }
    }
    return resultPtr;
}

7.具体代码实现

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

#define TOTAL_SPACE 5

typedef struct CircleIntQueue
{
	int data[TOTAL_SPACE];
	int head;
	int tail;
}*CircleIntQueuePtr;

CircleIntQueuePtr initQueue()
{
	CircleIntQueuePtr resultPtr=(CircleIntQueuePtr)malloc(sizeof(struct CircleIntQueue));
	resultPtr->head=0;
	resultPtr->tail=0;

	return resultPtr;
}

void enqueue(CircleIntQueuePtr paraPtr,int paraValue)
{
	if((paraPtr->tail+1)%TOTAL_SPACE==paraPtr->head)
	{
		printf("Queue full.\r\n");
		return ;
	}
	paraPtr->data[paraPtr->tail%TOTAL_SPACE]=paraValue;
	paraPtr->tail++;
}

int dequeue(CircleIntQueuePtr paraPtr)
{
	int resultValue;
	if(paraPtr->head==paraPtr->tail)
	{
		printf("No element in the queue.\r\n");
		return -1;
	}

	resultValue=paraPtr->data[paraPtr->head%TOTAL_SPACE];
	paraPtr->head++;

	return resultValue;
}

int queuelength(CircleIntQueuePtr paraPtr)
{
	int length=0;
	for(int i=paraPtr->head;i<paraPtr->tail;i++)
	{
		length++;
	}
	return length;
}
/**
 * Output the queue.
 */
void outputLinkQueue(CircleIntQueuePtr paraPtr)
{
	int i;
	if(paraPtr->head==paraPtr->tail)
	{
		printf("Empty queue.");
		return ;
	}
	printf("Element in the queue:");
	for(i=paraPtr->head;i<paraPtr->tail;i++)
	{
		printf("%d ",paraPtr->data[i%TOTAL_SPACE]);
	}
	printf("\r\n");
}

void testLinkQueue()
{
	printf("---Begin!---\r\n");
	int i=10;
	CircleIntQueuePtr tempPtr =initQueue();
	for(i;i<16;i++)
	{
		enqueue(tempPtr,i);
	}
	outputLinkQueue(tempPtr);
	printf("Length of the queue is %d\r\n",queuelength(tempPtr));

	for(i=0;i<6;i++)
	{
		printf("dequeue gets %d\r\n",dequeue(tempPtr));
	}
	enqueue(tempPtr,8);
	outputLinkQueue(tempPtr);
	printf("---End!---\r\n");
}
int main()
{
	testLinkQueue();
	return 0;
}

8、样例输出

The first matrix:
2, 4,
3, 1,
2, 1,
The second matrix:
7, 7, 6, 8,
4, 4, 5, 6,
sum=30, sum=30, sum=32, sum=40, sum=25, sum=25, sum=23, sum=30, sum=18, sum=18, sum=17, sum=22, The result is:
30, 30, 32, 40,
25, 25, 23, 30,
18, 18, 17, 22,
(0,0):11235192;
(0,1):11235196;
(0,2):11235200;
(0,3):11235204;
(0,4):11235208;
(1,0):11235212;
(1,1):11235216;
(1,2):11235220;
(1,3):11235224;
(1,4):11235228;
(2,0):11235232;
(2,1):11235236;
(2,2):11235240;
(2,3):11235244;
(2,4):11235248;
(3,0):11235252;
(3,1):11235256;
(3,2):11235260;
(3,3):11235264;
(3,4):11235268;

二、压缩矩阵的转置

1.矩阵压缩的定义

矩阵的压缩实际上就是将一个矩阵写成一个列数为3，行数为有效数个数的矩阵。
压缩矩阵

2.结构体的定义

typedef struct Triple
{
    int i;
    int j;
    elem e;
}Triple,*TriplePtr;

typedef struct CompressedMatrix
{
    int row;//行数
    int col;//列数
    int num;//有效数据个数
    Triple* element;//压缩矩阵
}CompressedMatrix,*CompressedMatrixPtr;

3.初始化

CompressedMatrixPtr initCompressedMatrix(int paraRow,int paraCol,int paraElement,int** paraData)
{
    int i;
    CompressedMatrixPtr resultPtr=(CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
    resultPtr->row=paraRow;
    resultPtr->col=paraCol;
    resultPtr->num=paraElement;
    resultPtr->element=(TriplePtr)malloc(paraElement*sizeof(struct Triple));

    for(i=0;i<paraElement;i++)
    {
        resultPtr->element[i].i=paraData[i][0];
        resultPtr->element[i].j=paraData[i][1];
        resultPtr->element[i].e=paraData[i][2];
    }
    return resultPtr;
}

4.矩阵的打印

void printCompressedMatrix(CompressedMatrixPtr paraPtr)
{
    for(int i=0;i<paraPtr->num;i++)
    {
        printf("(%d,%d):%d\r\n",paraPtr->element[i].i,paraPtr->element[i].j,paraPtr->element[i].e);
    }
}

5.压缩矩阵的转置

CompressedMatrixPtr transposeCompressedMatrix(CompressedMatrixPtr paraPtr)
{
    int i,tempCol,tempPosition;
    int* tempColCounts=(int*)malloc(paraPtr->col*sizeof(int));
    int* tempOffSet=(int*)malloc(paraPtr->col*sizeof(int));

    for(i=0;i<paraPtr->col;i++)
    {
        tempColCounts[i]=0;
    }

    CompressedMatrixPtr resultPtr=(CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
    resultPtr->row=paraPtr->col;
    resultPtr->col=paraPtr->row;
    resultPtr->num=paraPtr->num;

    resultPtr->element=(TriplePtr)malloc(paraPtr->num*sizeof(struct Triple));

    for(i=0;i<paraPtr->num;i++)
    {
        tempColCounts[paraPtr->element[i].j] ++;
    }
    tempOffSet[0]=0;
    for(i=1;i<paraPtr->col;i++)
    {
        tempOffSet[i]=tempOffSet[i-1]+tempColCounts[i-1];
        printf("tempOffSet[%d]=%d\r\n",i,tempOffSet[i]);
    }
    for(i=0;i<paraPtr->num;i++)
    {
        tempCol=paraPtr->element[i].j;
        tempPosition=tempOffSet[tempCol];
        resultPtr->element[tempPosition].i=paraPtr->element[i].j;
        resultPtr->element[tempPosition].j=paraPtr->element[i].i;
        resultPtr->element[tempPosition].e=paraPtr->element[i].e;

        tempOffSet[tempCol]++;
    }
    return resultPtr;
}

6.具体代码实现

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

typedef int elem;

typedef struct Triple
{
    int i;
    int j;
    elem e;
}Triple,*TriplePtr;

typedef struct CompressedMatrix
{
    int row;//行数
    int col;//列数
    int num;//有效数据个数
    Triple* element;//压缩矩阵
}CompressedMatrix,*CompressedMatrixPtr;

CompressedMatrixPtr initCompressedMatrix(int paraRow,int paraCol,int paraElement,int** paraData)
{
    int i;
    CompressedMatrixPtr resultPtr=(CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
    resultPtr->row=paraRow;
    resultPtr->col=paraCol;
    resultPtr->num=paraElement;
    resultPtr->element=(TriplePtr)malloc(paraElement*sizeof(struct Triple));

    for(i=0;i<paraElement;i++)
    {
        resultPtr->element[i].i=paraData[i][0];
        resultPtr->element[i].j=paraData[i][1];
        resultPtr->element[i].e=paraData[i][2];
    }
    return resultPtr;
}

void printCompressedMatrix(CompressedMatrixPtr paraPtr)
{
    for(int i=0;i<paraPtr->num;i++)
    {
        printf("(%d,%d):%d\r\n",paraPtr->element[i].i,paraPtr->element[i].j,paraPtr->element[i].e);
    }
}

CompressedMatrixPtr transposeCompressedMatrix(CompressedMatrixPtr paraPtr)
{
    int i,tempCol,tempPosition;
    int* tempColCounts=(int*)malloc(paraPtr->col*sizeof(int));
    int* tempOffSet=(int*)malloc(paraPtr->col*sizeof(int));

    for(i=0;i<paraPtr->col;i++)
    {
        tempColCounts[i]=0;
    }

    CompressedMatrixPtr resultPtr=(CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
    resultPtr->row=paraPtr->col;
    resultPtr->col=paraPtr->row;
    resultPtr->num=paraPtr->num;

    resultPtr->element=(TriplePtr)malloc(paraPtr->num*sizeof(struct Triple));

    for(i=0;i<paraPtr->num;i++)
    {
        tempColCounts[paraPtr->element[i].j] ++;
    }
    tempOffSet[0]=0;
    for(i=1;i<paraPtr->col;i++)
    {
        tempOffSet[i]=tempOffSet[i-1]+tempColCounts[i-1];
        printf("tempOffSet[%d]=%d\r\n",i,tempOffSet[i]);
    }
    for(i=0;i<paraPtr->num;i++)
    {
        tempCol=paraPtr->element[i].j;
        tempPosition=tempOffSet[tempCol];
        resultPtr->element[tempPosition].i=paraPtr->element[i].j;
        resultPtr->element[tempPosition].j=paraPtr->element[i].i;
        resultPtr->element[tempPosition].e=paraPtr->element[i].e;

        tempOffSet[tempCol]++;
    }
    return resultPtr;
}

void compressedMatrixTest()
{
    CompressedMatrixPtr tempPtr1,tempPtr2;

    int i,j,tempElement;

    tempElement=4;
    int** tempMatrix1=(int**)malloc(tempElement*sizeof(int*));
    for(i=0;i<tempElement;i++)
    {
        tempMatrix1[i]=(int*)malloc(3*sizeof(int));
    }

    int tempMatrix2[4][3]={{0,0,2},{0,2,3},{2,0,5},{2,1,6}};
    for(i=0;i<tempElement;i++)
    {
        for(j=0;j<3;j++)
        {
            tempMatrix1[i][j]=tempMatrix2[i][j];
        }
    }
    tempPtr1=initCompressedMatrix(2,3,4,tempMatrix1);

    printf("After initialization.\r\n");
    printCompressedMatrix(tempPtr1);

    tempPtr2=transposeCompressedMatrix(tempPtr1);
    printf("After transpose.\r\n");
    printCompressedMatrix(tempPtr2);
}
int main()
{
    compressedMatrixTest();
    return 0;
}

7.样例输出

After initialization.
(0,0):2
(0,2):3
(2,0):5
(2,1):6
tempOffSet[1]=2
tempOffSet[2]=3
After transpose.
(0,0):2
(0,2):5
(1,2):6
(2,0):3

ALuoJi
关注
专栏目录
R语言自学笔记-----数据结构之矩阵的定义及基本操作
qq_59022967的博客
01-12 2695
介绍一下关于R中矩阵的建立与基本操作的个人理解，如有错误欢迎指出
数据结构-矩阵
莫影 is Joker
10-06 783
#include &lt;iostream&gt; #include &lt;stdlib.h&gt; using namespace std; //矩阵类 template &lt;typename T&gt; class matrix { friend ostream&amp; operator&lt;&lt;(ostream&amp; out,const matrix&lt;T&gt;&a...
数据结构与算法——矩阵
最新发布
m0_58683132的博客
08-02 1631
矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合，它是一个二维的数据结构，由行和列组成，通常用来表示二维的数据集合。在数学中，矩阵最早来自于方程组的系数及常数所构成的方阵，这一概念由19世纪英国数学家凯利首先提出。在数据结构中，矩阵主要讨论如何在节省存储空间的前提下，正确高效地运算矩阵。
数据结构：矩阵
07-22 3713
使用数组表示矩阵存储： 学过线性代数的我们都知道，矩阵其实就是一个二维的表格，那么数据结构中的矩阵其实也是一样的，计算机中可以用矩阵这种形式来存储数据。那么我么怎么表示矩阵呢？在这里我们仍然可以使用数组来表示，不过，矩阵始终是个二维的东西，那么我们怎么用数组来表示二维的表格？ 答案很简单，使用二维数组即可！ 什么二维数组，其实一句话就是：数组里面的元素还是数组。比如说这个亚子。 我们知...
数据结构——矩阵
weixin_45927758的博客
05-28 296
#include<iostream> #include<vector> #include<algorithm> #include<string> #define MAXSIZE 100 using namespace std; //对特殊矩阵的操作 class spematrix { public: //保存上三角 void saveup(vector<vector<int>>&mtx,int mu) .
数据结构--矩阵
m0_62476845的博客
10-22 2145
数组和广义表，可看成是线性表的扩展。即线性表中的数据元素既可以是单个元素，也可以是一个线性结构。数组中的每个数据元素可用类型相同的数组来表示；广义表则比较灵活，每个数据元素可以是不在分的原子类型，也可以是子表。数组和广义表都是常用的数据结构，在相关领域有着广泛的应用。数组是一种很多高级语言都支持的、应用广泛的数据类型，可以看作线性表的推广。数组作为一种数据类型。从逻辑结构上看，数组可以看成是一般线性表的特殊形式；二维数组可以看成是线性表的线性表。
数据结构之矩阵行列和相等的实例
08-29
主要介绍了数据结构之矩阵行列和相等的实例的相关资料,希望通过本文能帮助到大家，让大家掌握这部分内容，需要的朋友可以参考下
数据结构——矩阵.docx
07-11
数据结构中的矩阵是一种重要的数据组织形式，特别是在计算机科学和工程计算中广泛应用。矩阵可以表示二维数组，用于存储和处理大量的数值数据。在本实验报告中，重点是学习和实现稀疏矩阵的压缩存储以及矩阵的转置...
数据结构课程设计之矩阵
01-13
在数据结构课程设计中，矩阵是一种重要的抽象数据类型，它基于数组的概念，用于表示数学中的矩阵运算。矩阵是由行和列组成的元素集合，通常用于线性代数、图像处理、计算机图形学等领域。在此课程设计中，我们将深入...
数据结构 矩阵
11-18
数据结构 数组和广义表的相关知识，稀疏矩阵，是压缩思维的雏形，有利于对数组的进一步理解。代码绝对可以执行。里面有范例的运行结果截屏。
C数据结构矩阵的运算
12-29
printf("请输入系数矩阵的行数和列数(用逗号隔开)"); scanf("%d,%d",&i,&j); printf("请输入增广矩阵的行数和列数(用逗号隔开)"); scanf("%d,%d",&m,&n); printf("请输入系数矩阵:\n"); for(p=0;p<i;p++) for(q=0;q<j;q++) scanf("%f",&A[p][q]); printf("输出系数矩阵A:\n"); for(p=0;p<i;p++) for(q=0;q<j;q++) { printf("%10.2f",A[p][q]); if((q+1)%j==0) printf("\n"); } printf("请输入增广矩阵:\n"); for(p=0;p<m;p++) for(q=0;q<n;q++) scanf("%f",&B[p][q]); printf("输出增广矩阵B:\n");
数据结构 矩阵的实现
11-26
矩阵在很多方面都起着作用，希望这个程序对学数据结构的人有点帮助，里面包含了矩阵的简单操作，矩阵初始化，销毁，赋值等功能
数据结构（矩阵1.转置2.快速转置）
12-18
矩阵的转置与快速转置皆有，遍历输出对比也在其中，有需要的自取，保证真是可用，小白也能入门！
数据结构——特殊矩阵
cdz2470的博客
04-27 4954
在线性代数里面，我们已经学过什么叫作方阵，即列数和行数相等的矩阵。对于特殊的方阵，我们不必将每一个元素都保存下来，在说这些矩阵之前，我们先来讲两种数组结构。
数据结构之矩阵实现
weixin_34391445的博客
10-28 178
https://blog.csdn.net/u012734723/article/details/72821088 转载于:https://www.cnblogs.com/zhoumin6012/p/9866869.html
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ALuoJi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值