数据结构（c语言） 多维数组和矩阵

最新推荐文章于 2024-05-10 16:47:31 发布
最新推荐文章于 2024-05-10 16:47:31 发布
阅读量6.7k 收藏 70
点赞数 10
分类专栏： 数据结构——C语言 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kkh01421/article/details/114796221
版权

一、数组

  • 可以是看作具有相同名称与相同数据类型的变量的集合，并且在内存中占据一块连续的内存空间。存取数组中的数据时，则需要使用下标来定位数据在数组中的位置。

数组包含下列五种属性

  1. 起始地址：表示数组名（或第一个元素）所在内存中的起始地址
  2. 维数：代表几维数组
  3. 下标的上下限：元素在数组中内存所存储的位置的最小值与最大值
  4. 数组元素个数：是下标上限与下标下限的差+1
  5. 数组类型：声明数组的类型决定数组元素在内存所占空间的大小。

1、一维数组

假设A为一维数组的名称，如果声明为A（1：n），表示A含有n个元素，其中1为下限，n为上限，则数组元素A（1）、A（2）等。a为A数组在内存中的起始位置，d为每一个数组元素所占用的空间，那么数组元素与内存地址有下列关系：

  • A（n） —— a+（n-1）*d
  • 在c语言中，一维数组的语法声明如下

数据类型 数组名【数组长度】

例如：int score [ 5 ]

//输出五名同学的成绩值并求和
#include<stdio.h>

int main(void)
{
	int score [5]={56,36,98,77,21};
	int sum=0;
	for(int i=1;i<=5;i++)
	{
		printf("第%d个同学成绩为：%d\n",i,score[i]);
		sum +=score[i];
	}
	printf("成绩总和为；%d",sum);
 } 
第1个同学成绩为：56
第2个同学成绩为：36
第3个同学成绩为：98
第4个同学成绩为：77
第5个同学成绩为：21
成绩总和为；288

2、二维数组

  • 二维数组的两种排列方式
  1. 以行为主：存放顺序为a11，a12，a1n，amm，假设a为数组在内存中的起始地址，d为单位空间，则数组元素aij与内存地址有下列关系：
  • Loc（aij）=a+n*（i-1）*d+（j-1）*d

     2、以列为主：存放顺序为a11，a21，am1，amm，同样的数组元素aij与内存地址有下列关系：

  • Loc（aij）=a+（i-1）*d+m*（j-1）*d
  • c语言中，二维数组的声明格式如下：

数据类型 二维数组名 【行大小】 【列大小】

例如：arr 【3】【5】

  • arr为一个3行5列的二维数组，也可以视为3x5的矩阵。使用的下标仍然是从0值开始计算

二维数组初始值的声明如下：

数据类型 数组名【n】【列大小】={{第0行初始值}，{第一行初始值}，...，{第n-1行初始值}}

例如：int arr 【2】【3】={{1，2，3}，{2，3，4}}

/*使用二维数组计算：
1、每个业务代表的前半年业绩总额
2、1-6个月每个月这三个业务代表的总业绩*/
#include<stdio.h>
int main(void){
	
int arr[3][6]={{112,76,95,120,98,68},{90,120,88,112,108,120},{108,99,126,90,76,98}};
int sum1,sum2=0;
	for(int b=0;b<3;b++){
		sum1=0;
		for(int i=0;i<6;i++){
		 sum1+=arr[b][i]; 
		}
		printf("\n第%d号销售员的前半年销售总金额为：%d\n",b+1,sum1);
		
	}
		
		
	for(int i=0;i<6;i++){
		sum2=0;
		 for(int j=0;j<3;j++){
		 	sum2+=arr[j][i];
		 }
		 printf("\n所有销售员%d月的销售总金额为%d：\n",i+1,sum2);
	}

}

第1号销售员的前半年销售总金额为：569

第2号销售员的前半年销售总金额为：638

第3号销售员的前半年销售总金额为：597

所有销售员1月的销售总金额为310：

所有销售员2月的销售总金额为295：

所有销售员3月的销售总金额为309：

所有销售员4月的销售总金额为322：

所有销售员5月的销售总金额为282：

所有销售员6月的销售总金额为286：
//使用二维数组来求二阶行列式
#include<stdio.h>

int main(void)
{
	printf("|a1 b1|\n");
	printf("|a2 b2|\n");
	int a1,b1,a2,b2=0;
	int arr[2][2]={{0,0},{0,0}};
	printf("请输入a1:");
	scanf("%d",&a1);
	arr[0][0]=a1;
	printf("请输入b1:");
	scanf("%d",&b1);
	arr[0][1]=b1;
	printf("请输入a2:");
	scanf("%d",&a2);
	 arr[1][0]=a2;
	printf("请输入b2:");
	scanf("%d",&b2);
	 arr[1][1]=b2;
	printf("|%d %d|\n",a1,b1);
	printf("|%d %d|\n",a2,b2);
	int sum=arr[0][0]*arr[1][0]-arr[0][1]*arr[1][1];
	printf("sum=%d",sum);
	
 } 
|a1 b1|
|a2 b2|
请输入a1:6
请输入b1:3
请输入a2:2
请输入b2:4
|6 3|
|2 4|
sum=0

3、多维数组

  • 二维数组以上的数组都被称为多维数组
  • 如果数组A声明为（1：u1，1：u2，1：u3），表示A为1个含有u1*u2*u3元素的三维数组，可以看作是立方体。
  1. 以行为主：使用转换公式来计算A（i，j，k）排列在第几位。首先可以将数组A视为u1个u2*u3的二维数组，再将每个二维数组视为有u2个一维数组，每一个一维数组包含u3个元素，假定每个元素有d个单位空间，且a为数组的起始地址，则地址计算公式为：
  • Loc（A（i，j，k））=a+(i-1)u2u3d+(j-1)u3d+(k-1)d

     2.以列为主：可以将数组A视为u3个u2*u1的二维数组，再将每个二维数组视为有u2个一维数组，每一个一维数组含有u1个元素。假定每个元素有d单位空间，且a为起始地址。则aijk元素的地址计算公式为：

  • Loc（A(aijk))=a+(k-1)u2u1d+(j-1)u1d+(i-1)d
  • 如果把数组A声明为A（l1:u1,l2:u2,l3:u3)的标注表示法，且对任意的aijk，有u1>=i>=l1,u2>=j>=l2,u3>=k>=l3，则m=（u1-l1+1），n=（u2-l2+1），o=（u3-l3+1），这样就可以把数组A视为有m个二维数组，再将每个二维数组视为有n个一维数组，每一个一维数组含有o个元素，则aijk的地址计算公式为：
  1. 以行为主：Loc（A(aijk))=a+(i-l1)nod+(j-l2)od+(k-l3)d
  2. 以列为主：Loc(A(aijk))=a+(k-l3)mnd+(j-l2)md+(i-l1)d
  • 在c语言中，多维数组的定义方式如下

数据类型 数组名【元素个数】 【元素个数】 【元素个数】....,【元素个数】

例如：float No【2】【2】【2】//三维数组

int arr【2】【3】【4】【5】//四维数组

  • 三维数组的遍历
#include<stdio.h>

int main(void){
	int arr[2][2][2]={{{1,2},{3,3}},{{3,6},{5,8}}};
	int i,j,k;
	for(i=0;i<2;i++){
		for(j=0;j<2;j++){
			for(k=0;k<2;k++){
				printf("arr[%d][%d][%d]=%d\n",i,j,k,arr[i][j][k]);
			}
		}
	}
arr[0][0][0]=1
arr[0][0][1]=2
arr[0][1][0]=3
arr[0][1][1]=3
arr[1][0][0]=3
arr[1][0][1]=6
arr[1][1][0]=5
arr[1][1][1]=8
  • 三维数组求和并将特殊值进行替换
//求取三维数组所元素值的总和，并将所有为负数的值替换为0 
#include<stdio.h>

int main(void)
{
	int arr[4][3][3]={{{1,-2,3},{4,5,-6},{8,9,2}},{{7,-8,9},{10,11,12},{-1,3,2}},{{-13,14,15},{16,17,18},{3,6,7}}
	,{{19,20,21},{-22,23,24},{-6,9,12}}};
	int i,j,k;
	int sum=0;
	int cnt=0;
	for(i=0;i<4;i++){
		for(j=0;j<3;j++){
			for(k=0;k<3;k++){
			sum+=arr[i][j][k];
			if(arr[i][j][k]<0){
				arr[i][j][k]=0;
			}
		}
	}
}
		for(i=0;i<4;i++){
		for(j=0;j<3;j++){
			for(k=0;k<3;k++){
			printf("%d  ",arr[i][j][k]);
			cnt++;
			if(cnt%9==0)
			printf("\n\n");
		}
	}
	}printf("\n原数组的和为：%d",sum); 
} 
1  0  3  4  5  0  8  9  2

7  0  9  10  11  12  0  3  2

0  14  15  16  17  18  3  6  7

19  20  21  0  23  24  0  9  12


原数组的和为：252
  • 三维数组查找最小值
#include<stdio.h>

int main(void){
	
	int arr[2][3][3]={{{33,45,67},{23,71,56},{55,38,66}},{{21,9,15},{38,69,18},{90,101,89}}};
	
	int min=arr[0][0][0];
	int i,j,k;
	for(i=0;i<2;i++){
		for(j=0;j<3;j++){
			for(k=0;k<3;k++){
				if(min>arr[i][j][k]){
					min=arr[i][j][k];
				}
			}
		}
	}
	printf("最小值=%d\n",min);
}
最小值=9

4、结构数组

  • 结构数组允许用户自定义数据类型，又称为派生数据类型。

结构类型必须具有结构名称以及结构项目，而且必须使用关键字struct来创建，一个结构的基本声明方式如下：

struct 结构名称{

        数据类型 结构成员1；

        数据类型 结构成员2；

        ....

};

例如：struct student{

          char name[10];

          int score;

          int ID;

};

  • 在定义了结构之后，可以直接使用它来创建结构对象。
  • 结构对象的创建

1.直接创建

例如：struct s1,s2;

2.在定义结构的同时声明结构变量

例如：

struct student{

          char name[10];

          int score;

          int ID;

}s1,s2;

结构对象的使用

  • 在创建结构对象之后，可以使用英文句号.来存取结构成员，该句号被称为点运算符。

使用如下：结构变量.项目成员名称

例如：

strcpy(s1.name,"zhangsan');

s1.score=90;

s1.ID=10001;

结构数组是将结构数据类型与数组相结合的应用。

声明方式如下：

  • struct 结构类型名称 结构数组名【元素个数】

例如：

struct student {

        char name【10】；

         int math；

         int English；

}；

struct student class1【5】；

  • 要存取数组的结构成员，在数组后方加上“【下标值】‘再加上成员名称即可，例如：

结构数组名【下标值】.成员名称

#include<stdio.h>

int main(void){
	struct stu{
		char name[10];
		int math;
		int Englishi;
	};//定义结构
	struct stu group[3]={{"zhangsan",87,63},{"lisi",92,87},{"wangmazi",63,98}};//定义并设置结构数组的初始值 
	int i;
    float math_sum,eng_sum=0;
	for(i=0;i<3;i++){
		math_sum+=group[i].math;
		eng_sum+=group[i].Englishi;
		printf("姓名：%s\t数学成绩：%d\t英语成绩：%d\t\n",group[i].name,group[i].math,group[i].Englishi);
	}
	for(i=0;i<50;i++){
		printf("=");
	}
}
姓名：zhangsan  数学成绩：87    英语成绩：63
姓名：lisi      数学成绩：92    英语成绩：87
姓名：wangmazi  数学成绩：63    英语成绩：98
==================================================

5、字符数组

c语言中，没有称为字符串的基本数据类型，如果在c程序中存储字符串，就必须使用字符数组来表示。

  • 例如：‘a’是一个字符常数，而“a”是一个字符串常数。差别在于字符串的末尾处会多安排一个字节的空间来存放”\0“字符，作为字符串结束的符号。

字串的声明如下：

  • 方式一：char 字符串常量【字符串长度】=“ 初始字符串”；
  • 方式二：char 字符串常量【字符串长度】={‘字符1’，‘字符2’，...‘字符n’，‘\0’};

例如：

  • char str1[6]="Hello";
  • char str2[6]={'H','e','l','l','o','\0'};
  • char str3[ ]="Hello";
  • 注意：由于字符串不是C的基本数据类型，无法利用数组名来直接给另一个字符串数组赋值，如果需要进行字符串的赋值，必修从字符串数组中一个一个取出元素的内容进行复制。

字符串长度的计算

int main(void){
	int n;
	char str[100];
	printf("请输入字符串：");
	scanf("%s",&str);
	while(str[n]!='\0'){
		n++;
	}
	printf("\n输入的字符串为%s\n",str);
	printf("此字符串有%d个字符",n);
} 
请输入字符串：aksdkaksda
输入的字符串为aksdkaksda
此字符串有10个字符

字符串大小写的转换

int main(void){
	char s[100];
	printf("请输入一个字符串:");
	scanf("%s",&s);
	int n=0;
	while(s[n]!='\0'){
		if(s[n]>='a'&&s[n]<='z'){
			s[n]-=32;
		}
		n++;
	}
	printf("\n大小写转换后的字符串为%s\n",s);
}
请输入一个字符串:lasdkasd

大小写转换后的字符串为LASDKASD

字符串的反转

int main(void){
	char s[100];
	printf("请输入一个字符串:");
	scanf("%s",&s);
	int n=0;
	while(s[n]!='\0'){
		n++;
	}
	printf("字符串反转后为："); 
	for(int len=n;len>=0;len--){
		printf("%c",s[len]);
	}
	
}
请输入一个字符串:lobeadsada
字符串反转后为： adasdaebol

6、字符串数组

  • 字符串数组可以理解为二维的字符数组

字符串数组的声明方式如下

  • char 字符串数组名【字符串数】 【字符数】;
  • 上述字符串数表示字符串的个数，而字符数表示的是每个字符串最多可容纳多少字符。

字符串数组也可以在声明时就设置初始值

char 字符串数组名【字符串数】【字符数】={“字符串常数1”，“字符串常数2”，“字符串常数3”，...};

  • 例如：char Name[5] [10] ={ "John","Mary","Wilson","Candy","Allen"};

字符串数组的遍历

int main(void){
	char name[5][20]={"zhangsan","lisi","wangmaizi", 
					  "wangwu","huangsan"};
	for(int i=0;i<5;i++){
		printf("name[%d]=%s\n",i,name[i]);
	}
}
name[0]=zhangsan
name[1]=lisi
name[2]=wangmaizi
name[3]=wangwu
name[4]=huangsan

7、指针数组

  • 每个指针数组中的元素都是一个指针变量，而元素值则为只想其他变量的地址值

一维指针数组的声明格式：

数据类型 *数组名【元素名称】；

例如：

  • int *p【3】； float *ptr【4】；

一维指针数组应用于字符串存储中可避免字符串数组中对于内存空间的浪费

例如：char *name【4】={“zhangsan”，"lisi" ，“wangmazi”，“wangwu”}；

  • 该声明中，每个数组元素name【i】都是用来存储内存的地址，他们分别存储了指向字符串的内存地址。

二、矩阵

  • 对于m x n矩阵的形式，可以用A（m，n）的二维数组来描述。

1、矩阵的运算

转置矩阵：把原矩阵的行坐标与列坐标相互调换，假设At为A的转置矩阵，则有At【j，i】=A【i，j】

  • 算法如下
for(i=0;i<m;i++){
    for(j=0;j<n;j++){
        arrB[i][j]=arrA[i][j];
    }
}
  • 4*4矩阵的转置
int main(void){
	int arrA[4][4];
	int arrB[4][4];
	int i,j;
	int cnt=0;
	printf("【请输入矩阵的内容】\n"); 
	for(i=0;i<4;i++){
		for(j=0;j<4;j++){
			scanf("%d",&arrA[i][j]);
			
		}
	}
	printf("\n【转置的矩阵内容为】\n");
	for(i=0;i<4;i++){
		for(j=0;j<4;j++){
			arrB[i][j]=arrA[j][i];
			printf("%d ",arrB[i][j]);
			cnt++;
			if(cnt%4==0){
				printf("\n");
			}
		}
	} 
}
【请输入矩阵的内容】
1 2 3 4
3 2 1 4
6 6 6 6
5 8 5 9

【转置的矩阵内容为】
1 3 6 5
2 2 6 8
3 1 6 5
4 4 6 9

矩阵的加法运算

  • 相加的两个矩阵行数与列数必须相等，相加后矩阵的行数与列数也必须相同。
2个m*n矩阵相加的算法如下：
for（i=0；i<3;i++)
    for(j=0;j<3;j++)
    C[i][j]= A[i][j]+B[i][j];//矩阵C=矩阵A+矩阵B
#include<stdio.h>

int main(void){
	int a[3][3]={{2,3,4},{4,5,6},{5,6,9}};
	int b[3][3]={{3,4,5},{6,7,8},{2,6,8}};
	int c[3][3];
	int i,j;
	int cnt=0;
	printf("矩阵相加后结果为：\n");
	for(i=0;i<3;i++){
		for(j=0;j<3;j++){
			c[i][j]=a[i][j]+b[i][j];
			cnt++;
			printf(" %d ",c[i][j]);
			if(cnt%3==0){
				printf("\n");
			}
			
		}
	}
} 
矩阵相加后结果为：
 5  7  9
 10  12  14
 7  12  17

矩阵的乘法运算

  • 矩阵A*B，首先必须符合A为一个m*n矩阵，B为一个n*p矩阵，A*B之后的结果为一个m*p的矩阵C。
m*n矩阵与n*怕矩阵相乘的算法如下
for(i=0;i<3;i++)
    for(j=0;j<3;j++)
    {
    c[i][j]=0;
    for(k=0;k<2;k++)
    c[i][j]=c[i][j]+A[i][k]*B[k][j];
    }//矩阵C=矩阵A*矩阵B
#include<stdio.h>

int main(void){
	int i,j,k,m,n,p,q;

	printf("请输入矩阵a的维数(m,n):\n");
	scanf("%d %d",&m,&n);
	int a[m][n]={0};
	printf("【请输入矩阵a的元素】\n");
	for(i=0;i<m;i++){
		for(j=0;j<n;j++){
			printf("a%d%d=",i,j);
			scanf("%d",&a[i][j]);
		}
	}
	getchar();
	printf("请输入矩阵b的维数(n,p):\n");
	scanf("%d %d",&p,&q	);
	int b[n][p]={0};
	printf("【请输入矩阵b的元素】\n");
	for(i=0;i<p;i++){
		for(j=0;j<q;j++){
			printf("b%d%d=",i,j);
			scanf("%d",&b[i][j]);
		}
	}
	getchar(); 
	printf("a*b的结果为：\n");
	int c[m][p]={0};
	int cnt=0;
	printf("%d %d %d\n",m,n,p);
	for(i=0;i<m;i++){
		for(j=0;j<p;j++){
			
			c[i][j]=0;
			for(k=0;k<n;k++){
				c[i][j]=c[i][j]+a[i][k]*b[k][j];
				}
				
			}
		}
	
	for(i=0;i<m;i++){
		for(j=0;j<m;j++){
			printf(" %d ",c[i][j]);
			cnt++;
			if(cnt%2==0){
				printf("\n");
			}
		}
	} 
}
请输入矩阵a的维数(m,n):
2 3
【请输入矩阵a的元素】
a00=1
a01=2
a02=3
a10=4
a11=5
a12=6
请输入矩阵b的维数(n,p):
3 2
【请输入矩阵b的元素】
b00=6
b01=5
b10=4
b11=3
b20=2
b21=1
a*b的结果为：
2 3 3
 20  14
 56  41

2、稀疏矩阵

  • 如果一个矩阵中的大部分元素为零的话，就被称为稀疏矩阵。
  • 稀疏矩阵实际存储的数据项很少，若果在计算机中使用传统的二维数组来存储十分浪费内存空间。提高利用率的方法时利用三项式的数据结构。
  • 三项式：将每一个非零项以（i，j，item-value）来表示。i表示所在行数，j表示所在列数，item-value表示数值。
  • 如果一个稀疏矩阵由n个非零项，可以利用A（0：n，1：3）的二维数组来存储这些非零项，把这样存储的矩阵叫作压缩矩阵。其中A（0，1）存储这个矩阵的行数，A（0，2）存储这个稀疏矩阵的列数，而A（0：3）是此稀疏矩阵除非零项的总数。
  • 存取压缩数组的算法：
Compress[0][0]=6;//此稀疏矩阵的行数
Comperss[0][1]=6;//此系数矩阵的列数
Compress[0][2]=NONZERO;//此稀疏矩阵除非零项的总数
for(i=0;i<6;i++)
    for(j=0;j<6;j++)
    if(Spare[i][j]!=){
        Compress[temp][0]=i;
        Compress[temp][1]=j;
        Compress[temp][2]=Sparse[i][j];
        temp++;
        }
  • 6*6稀疏矩阵的压缩
#include<stdio.h>

int main(void){
	int a[6][6]={};
	int i,j,k,cnt=0;
	int n=0;
	int temp=0; 
	printf("【请为矩阵赋值】\n");
	for(i=0;i<6;i++){
		for(j=0;j<6;j++){
			printf("a%d%d=",i,j);
			scanf("%d",&a[i][j]);
			if(a[i][j]!=0){
				n++;
			}
		}
	}
	
	printf("\n【稀疏矩阵的各个元素】\n"); 
	 for(i=0;i<6;i++){
		for(j=0;j<6;j++){
			printf("[%d]\t",a[i][j]);
			if(a[i][j]!=0){
			}
			cnt++;
			if(cnt%6==0){
				printf("\n"); 
			}
			
		}
	}
	int c[100][3]={};

	printf("\n【稀疏矩阵压缩后内容】\n");
	c[0][0]=6;
	c[0][1]=6;
	c[0][2]=n;
	for(int m=0;m<3;m++){
		printf("[%d]\t",c[0][m]);
	}
	printf("\n");
	int cnts=1;
	for(i=0;i<6;i++){
		for(j=0;j<6;j++){
			if(a[i][j]!=0){
				
			c[temp][0]=i;
			c[temp][1]=j;
			c[temp][2]=a[i][j];
			 temp++;
		 }	
	  }
	}
  for(i=0;i<temp;i++){
  	for(j=0;j<3;j++){
  		printf("[%d]\t",c[i][j]);
  		cnt++;
  		if(cnt%3==0)
  		printf("\n");
	  }
  }
}
【请为矩阵赋值】
a00=0
a01=0
a02=0
a03=0
a04=0
a05=0
a10=0
a11=0
a12=0
a13=0
a14=0
a15=0
a20=0
a21=0
a22=0
a23=01
a24=2
a25=34
a30=5
a31=6
a32=3
a33=2
a34=1
a35=0
a40=3
a41=2
a42=1
a43=0
a44=3
a45=2
a50=1
a51=0
a52=5
a53=9
a54=9
a55=7

【稀疏矩阵的各个元素】
[0]     [0]     [0]     [0]     [0]     [0]
[0]     [0]     [0]     [0]     [0]     [0]
[0]     [0]     [0]     [1]     [2]     [34]
[5]     [6]     [3]     [2]     [1]     [0]
[3]     [2]     [1]     [0]     [3]     [2]
[1]     [0]     [5]     [9]     [9]     [7]

【稀疏矩阵压缩后内容】
[6]     [6]     [18]
[2]     [3]     [1]
[2]     [4]     [2]
[2]     [5]     [34]
[3]     [0]     [5]
[3]     [1]     [6]
[3]     [2]     [3]
[3]     [3]     [2]
[3]     [4]     [1]
[4]     [0]     [3]
[4]     [1]     [2]
[4]     [2]     [1]
[4]     [4]     [3]
[4]     [5]     [2]
[5]     [0]     [1]
[5]     [2]     [5]
[5]     [3]     [9]
[5]     [4]     [9]
[5]     [5]     [7]

--------------------------------

上三角形矩阵

  • 上三角形矩阵就是一种对角线以下元素都为0的n*n矩阵。上三角形矩阵又可以分为右上三角形与左上三角形矩阵。由于上三角形矩阵仍有许多元素为0，为节省内存空间。我们可以把三角形矩阵的二维模式，存储在一维数组中。

1、右上三角形矩阵

  • 对于n*n的矩阵A，假如i>j,那么A（i，j）=0
  • 由于此二维矩阵的非零项可以按顺序映射到一维矩阵且需要一个一维数组B（1:n*(n+1)/2)来存储。映射方式可以以行为主或者以列为主
  • 以行为主时：aij会存放在B（k）中。k=n*（i-1）-i*（i-1）/2   + j
  • 以列为主时：aij回存放在B（k）中。k=j*（j-1）/2    + i
  • 右上三角形压缩为一维数组的代码实现
#include<stdio.h>

int main(void){
	int m,n,i,j=0; 
	printf("请输入矩阵a的维数(m,n):\n");
	scanf("%d %d",&m,&n);
	int a[m][n]={0};
	int cnt1=0;
	printf("【请输入矩阵a的元素】\n");
	for(i=0;i<m;i++){
		for(j=0;j<n;j++){
			if(i<=j){
			printf("a%d%d=",i,j);
			scanf("%d",&a[i][j]);
			cnt1++;
			}else{
				a[i][j]=0;
			} 
		}
	}
	printf("\n上三角形矩阵:\n");
	int b[cnt1]={0};
	int cnt2=0;
	for(i=0;i<m;i++){
		for(j=0;j<n;j++){
			printf("%d\t",a[i][j]);
			cnt2++;
			if(cnt2%n==0){
				printf("\n");
			}
		}
	}printf("\n以一维数组的方式表示：\n");
		int k=0;
	for(i=0;i<m;i++){
		for(j=0;j<n;j++){
			if(a[i][j]!=0){
				b[k]=a[i][j];
				printf("%d\t",b[k]);
				k++;
			}
		}
	}
  } 
请输入矩阵a的维数(m,n):
3 3
【请输入矩阵a的元素】
a00=1
a01=2
a02=3
a11=4
a12=5
a22=6

上三角形矩阵:
1       2       3
0       4       5
0       0       6

以一维数组的方式表示：
1       2       3       4       5       6

2、左上三角形矩阵

  • n*n的矩阵A，假如i>n-j+1时，A（i，j）=0.
  • 以行为主：k=n*（i-1）-(（i-2）*（i-1))/2+j
  • 以列为主：k=n*（j-1）-（（j-2）*（j-1））/2+i

下三角形矩阵

  • 对角线以上元素都为0的n*n矩阵。

1、左下三角形矩阵

  • 即对n*n的矩阵A，假如i>n-j+1时，A（i，j）=0
  • 以行为主：将aij存储在B（k）中，k=n*（i-1）-（（i-2）*（i-1））/2   + j
  • 以列为主：将aij存储在B（k）中，k=n*（j-1）-（（j-2）*（j-1））/2   + i
  • 左下三角形矩阵压缩为一维数组的代码实现
#include<stdio.h> 

int main(void){
	int m,n,i,j=0; 
	printf("请输入矩阵a的维数(m,n):\n");
	scanf("%d %d",&m,&n);
	int a[m][n]={0};
	int cnt1=0;
	printf("【请输入矩阵a的元素】\n");
	for(i=0;i<m;i++){
		for(j=0;j<n;j++){
			if(i>=j){
			printf("a%d%d=",i,j);
			scanf("%d",&a[i][j]);
			cnt1++;
			}else{
				a[i][j]=0;
			} 
		}
	}
	printf("\n下三角形矩阵:\n");
	int b[cnt1]={0};
	int cnt2=0;
	for(i=0;i<m;i++){
		for(j=0;j<n;j++){
			printf("%d\t",a[i][j]);
			cnt2++;
			if(cnt2%n==0){
				printf("\n");
			}
		}
	}printf("\n以一维数组的方式表示：\n");
		int k=0;
	for(i=0;i<m;i++){
		for(j=0;j<n;j++){
			if(a[i][j]!=0){
				b[k]=a[i][j];
				printf("%d\t",b[k]);
				k++;
			}
		}
	}
  } 

请输入矩阵a的维数(m,n):
3 3
【请输入矩阵a的元素】
a00=1
a10=2
a11=3
a20=4
a21=5
a22=6

下三角形矩阵:
1       0       0
2       3       0
4       5       6

以一维数组的方式表示：
1       2       3       4       5       6
--------------------------------

2、右下三角形矩阵

  • 对于n*n的矩阵，假如i<n-j+1,那么A（i，j）=0.
  • 以行为主：aij存储在B（k）中，k=i*(i+1)/2   +j-n
  • 以列为主：aij存储在B（k）中，k=j*(j+1)/2   +i-n

带装矩阵

  • 在上三角形矩阵中，右上方的元素均为零。在下三角形矩阵中，左下方的元素也为零。即除了第一行与第n行有两个元素外，其余每行都具有三个元素。
  • 带状矩阵也是稀疏矩阵的一种。在存储上也只将非零项存储到一维数组中，映射关系同样为以行为主或者以列为主。
  • 例如，对以行为主的存储方式。aij存储到B(k)中，k=2i+j-2。
快乐麦肯
关注
专栏目录
c语言之矩阵
m0_62633482的博客
07-10 1万+
c语言之矩阵（转置矩阵，上三角矩阵，杨氏矩阵）
程序员“修炼成神”的必经之路——数据结构（第4章 多维数组和广义表）
weixin_45676761的博客
11-26 4489
本篇博客简单分享数据结构中的多维数组和广义表。小伙伴们快点进来看看吧！多维数组和广义表是一种复杂的非线性结构，它们的逻辑特征是：一个数据元素可能有多个直接前趋和直接后继。
数组、矩阵、图的介绍
electronic_J的博客
08-19 365
度：依附于顶点的边的数量称之为该顶点的度，有向图中，度分为出度(从该顶点出发的弧的数量)、入度(指向该顶点的弧的数量)生成树：顶点数为n，仅需要n-1条边的连通图，称之为生成树，如果给边配上权重，权重和最小的生成树称之为最小生成树。连通图：任意顶点之间都是连通的，称之为连通图，如果一个图中有n个顶点则至少需要 n-1 条边才能达到连通图。注意：不讨论顶点到自身的边，且不讨论重复的边，这种图统称为简单图，数据结构中只研究简单图。边的权重：图中的边附带有意义的数据，这些数据叫做边的权重，带权重的图也称为网。
数据结构学习笔记——多维数组、矩阵
小宇y的博客
11-22 1333
数组是由n（n≥1）个相同数据类型的数据元素组成的有限序列，在定义数组时，会为数组分配一个固定大小的内存空间，用来存储元素，数组在被定义后，其维度不可以被改变。数组在确定其维度和维界后，元素的个数是固定的，所以不能进行插入和删除运算。数组中最常见的两种操作是查找和修改。广义表是线性表的进一步推广，是由n（n≥0）个数据元素组成的有序序列。线性表中的数据元素只能是单个元素（原子），它是不可分割的，而广义表中的数据元素既可以是原子，也可以是一个广义表（包括空表和非空表），广义表通过圆括号“()
数据结构（15）：数组的实现
欢迎来到关关雎鸠儿的博客
08-29 197
程序代码： #include <stdio.h> #include <stdlib.h> #include <stdarg.h> //标准头文件，提供宏va_start、va_arg和va_end用于存取变长参数表 #define MAX_ARRAY_DIM 8 //假设数组维数最大值为8 typedef struct { int *base; //...
数据结构：数组、矩阵、广义表
燕双嘤
03-15 408
1，数组 1.1，数组的定义 数组是数据结构的基本结构形式，它是一种顺序式的结构，数组是存储同一类型数据的数据结构。 数组是顺序存储的随机存取结构，数组是其他数据结构实现顺序存储的基础。 使用数组时需要定义数组的大小和存储数据的数据类型。 数组分为一维数组和多维数组。数组的维数是由数组下标的个数确定的： 一个下标称为一维数组。 一个下标以上的数组称为多维数组。 从这个意义上讲，确定了对于数组的一个下标总有一个相应的数值与之对应的关系；或者说数组是有限个同类型数据元素组成的序列。 数组是
c语言多维数组.pdf
09-30
标题《C语言多维数组.pdf》表示这份文件主要讨论的是C语言编程中关于多维数组的知识。 在C语言中，数组是一种数据结构，可以存储固定大小的顺序集合。数组元素可以是基本数据类型或派生类型。多维数组是数组的数组...
C语言数组，数组是一种基本的数据结构
01-10
了解这些基本操作后，开发者可以使用数组解决更复杂的编程问题，比如排序算法（冒泡排序、选择排序等）、查找算法（线性查找、二分查找）以及更高级的数据结构，如矩阵、多维数组和动态数组（指针数组）。...
C语言多维数组与指针应用实例
# 1. 引言 ## 1.1 C语言中的数组和指针基础知识回顾 在C语言中，数组是一组相同类型的元素的...指针是C语言中的重要概念，可以实现对内存地址的直接访问，使用指针可以更高效地操作数据结构和数组，也是实现动态内存分
【数据结构】多维数组
SuperSources的博客
11-08 773
（多维）数组——线性表中的数据元素可以是线性表，但所有元素的类型相同。 广义表——线性表中的数据元素可以是线性表，且元素的类型可以不相同。 数组的基本操作 ⑴ 存取：给定一组下标，读出对应的数组元素； ⑵ 修改：给定一组下标，存储或修改与其相对应的数组元素。 存取和修改操作本质上只对应一种操作——寻址 数组没有插入和删除操作，所以，不用预留空间，适合采用顺序存储。 数组的存储结构与寻址——一维数...
数据结构--多维数组
钟真龙的博客
12-30 1305
从逻辑结构上看，多维数组可以认为是一维数组的扩展，从物理结构上看，一维数组是多维数组的特例。 我本人是这样构想的，比如看待二维数组：一维数组中的每个元素都是一维数组。 多维数组的逻辑特征是：一个元素可能有多个直接前驱和多个直接后继。 数组顺序表的定义 把数组中的元素按照逻辑次序存放在一组地址连续的存储单元的方式称为数组的顺序存储结构，采用这种存储结构的数组称为数组顺序表。 由于内存单元是一维结构，而数组是多个结构，因此用一组连续存储单元存放数组的元素存在一个次序问题。有两种顺序存储方式：列优先顺
数据结构基础(一)数组，矩阵
AlbertYang的博客
11-16 9920
数据结构基础(一) 有一个等式，数据结构+算法=程序,说明了数据结构对于计算机程序设计的重要性。数据结构是指数据元素的集合(或数据对象)及元素间的相互关系和构造方法。数据对象中元素之间的相互关系称为数据的逻辑结构，数据元素及元素之间关系的存储形式称为存储结构(或物理结构)。 数据结构按照逻辑关系的不同，分为线性结构和非线性结构两种，线性结构又可分为树结构和图结构。   1.1 数组 ...
数据结构-多维数组
coolingxyz的博客
11-20 1280
多维数组： 多维数组的定义和存储 多维数组和广义表是一种复杂的非线性结构，它们的逻辑特征是：一个数据元素可能有多个直接前驱和多个直接后继。 矩阵的存储 矩阵是科学与工程计算问题中常用的数学对象之一。 特殊矩阵 所谓特殊矩阵是指非零元素或零元素的分布有一定规律的矩阵。常见的有对称矩阵、三角矩阵和对角矩阵等。
数据结构复盘——第四章：数组和矩阵
时生的博客
10-17 244
涉及：矩阵、对称矩阵、三角矩阵、三对角矩阵、稀疏矩阵
【数据结构】数组（稀疏矩阵、特殊矩阵压缩、矩阵存储、稀疏矩阵的快速转置、十字链表）
ChenZHIHAO_y的博客
04-05 1424
数组（稀疏矩阵、特殊矩阵压缩、矩阵存储、稀疏矩阵压缩、稀疏矩阵的快速转置、十字链表）
数组和矩阵：数据结构与应用
程序员光剑
12-31 1196
1.背景介绍 数组和矩阵是计算机科学和数学领域中非常重要的数据结构和数学概念。它们在各种算法和应用中发挥着重要作用，例如图像处理、机器学习、数据挖掘等领域。本文将详细介绍数组和矩阵的基本概念、算法原理、应用和未来发展趋势。 1.1 数组 数组是一种线性数据结构，由一系列有序的元素组成。每个元素都有一个唯一的索引，用于标识其在数组中的位置。数组可以存储不同类型的数据，如整数、浮点数、字符串等。...
数据结构与算法要点总结（4）：数组、矩阵、字符串、广义表
wow_10086的博客
12-29 392
一维数组与一位数组的推广：一维数组与多维数组、特殊矩阵、稀疏矩阵。线性表的运用：字符串。广义表：一种递归形式的表。
软考（中级数据库）3 数据结构与算法（线性结构、数组、矩阵）
最新发布
nbatop5的博客
05-10 548
一个线性表是n个元素的有限序列(n大于等于0)，通常表示为(a1，a2，a3，......，an)。
C语言多维数组与矩阵转置详解
- **定义**: 多维数组是一类数据结构，它可以是一维、二维或更高维度，如一维数组（类似线性表或向量）、二维数组（向量的扩展）、三维数组以及更高级的多维数组，它们具有非线性结构，每个元素有多个直接前驱和后继...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值