C语言if函数生成矩阵 C语言生成矩阵

C语言如何生成一个随机矩阵

生产随机的矩阵的关键在于使用随机函数rand()。

网站制作、建网站找专业网站设计公司创新互联:定制网站、模板网站、仿站、重庆小程序开发、软件开发、成都app开发等。做网站价格咨询创新互联:服务完善、十余年建站、值得信赖!网站制作电话：18980820575

rand()

表头文件: #includestdlib.h

定义函数 :int rand(void)

函数说明 :

因为rand的内部实现是用线性同余法做的，他不是真的随机数，只不过是因为其周期特别长，所以有一定的范围里可看成是随机的，rand()会返回一随机数值，范围在0至RAND_MAX 间。在调用此函数产生随机数前，必须先利用srand()设好随机数种子，如果未设随机数种子，rand()在调用时会自动设随机数种子为1。rand ()产生的是假随机数字，每次执行时是相同的。若要不同,以不同的值来初始化它.初始化的函数就是srand()。

返回值:

返回0至RAND_MAX之间的随机整数值，RAND_MAX的范围最少是在32767之间（int），即双字节（16位数）。若用unsigned int 双字节是65535，四字节是4294967295的整数范围。

0~RAND_MAX每个数字被选中的机率是相同的.

基于随机函数，使用双重循环语句便可以生成一个随机矩阵，下面是一个10x10随机矩阵的代码，数值范围在0~1000：

#include stdio.h                     

#include stdlib.h                    

#define M 10                           

#define N 10                           

int main(void)                         

{                                      

int i = 0, j = 0;                  

int Arr[M][N] = {{0}};             

srand(time(NULL));                 

for (i = 0; i  M; ++i)            

{                                  

for (j = 0; j  N; ++j)        

{                              

Arr[i][j] = rand() % 1000; 

}                              

}                                  

printf("Array[%d][%d] is: \n", M, N);

for (i = 0; i  M; ++i)            

{                                  

for (j = 0; j  N; ++j)        

{                              

printf("%d\t", Arr[i][j]); 

}                              

printf("\n");                  

}                                  

return 0;                          

}

c语言中，如何生成一个5*5的随机矩阵，并且（重点）每行的相邻数之差在[-4,4]之间 ？

#include stdio.h

#include stdlib.h

#include time.h

#include limits.h

// 数组最大的尺寸常量

const int MAX_ARRAY_SIZE = 10;

// 表示一个区间的结构体

struct Range

{

// 区间的下限

int lower;

// 区间的上限

int upper;

};

//表示整个区间的一个特殊区间

const struct Range ALL_RANGE={INT_MIN,INT_MAX};

//表示空区间的一个特殊区间

const struct Range EMPTY_RANGE={INT_MAX,INT_MIN};

//取两个区间 r1,r2的交集，并返回

struct Range merge(struct Range r1,struct Range r2)

{

struct Range common;

if(r1.upper r2.lower || r1.lower r2.upper)

{

return EMPTY_RANGE;

}

else

{

common.lower = r1.lower r2.lower ? r1.lower : r2.lower;

common.upper = r1.upper r2.upper ? r1.upper : r2.upper;

return common;

}

}

//判断区间r是不是空的

int isEmpty(struct Range r)

{

return r.lower r.upper;

}

/*

生成随机数组

参数：

rowsAmount : 要产生的随机数组的行数

colsAmount : 要产生的随机数组的列数

rowValueDifferRange : 要产生的随机数组的行元素的差范围数

colValueDifferRange : 要产生的随机数组的列元素的差范围数

randArray : 保存产生的随机数组

currentRow : 当前要产生的数组元素行位置。递归使用。

currentCol : 当前要产生的数组元素列位置。递归使用。

*/

void generate( int rowsAmount,int colsAmount,

struct Range rowValueDifferRange,struct Range colValueDifferRange,

int randArray[][MAX_ARRAY_SIZE],

int currentRow,int currentCol)

{

struct Range currentRowValueRange = ALL_RANGE;

struct Range currentColValueRange = ALL_RANGE;

struct Range currentValueRange;

if(currentRow == rowsAmount)

return;

// 第一个随机数可以任意取

if(currentRow == 0 currentCol == 0)

{

// 生成当前的随机数

randArray[currentRow][currentCol] = rand();

}

else

{

// 根据当前已经存在的相邻列（在左边），决定要生成的随机数的范围

if(currentCol0)

{

currentColValueRange.lower = randArray[currentRow][currentCol-1] + colValueDifferRange.lower;

currentColValueRange.upper = randArray[currentRow][currentCol-1] + colValueDifferRange.upper;

}

// 根据当前已经存在的相邻行（在上边），决定要生成的随机数的范围

if(currentRow0)

{

currentRowValueRange.lower = randArray[currentRow-1][currentCol] + rowValueDifferRange.lower;

currentRowValueRange.upper = randArray[currentRow-1][currentCol] + rowValueDifferRange.upper;

}

// 将由列决定的取值范围，和由行决定的取值范围，取交集

currentValueRange = merge(currentRowValueRange,currentColValueRange);

// 如果合并后的区间是空的，也就是说当前无法生成一个随机数。

if(isEmpty(currentValueRange))

{

if(currentCol==0)

{

currentRow--;

currentCol = colsAmount-1;

}

else

{

currentCol--;

}

// 需要从新生成上一个随机数

return generate(rowsAmount,colsAmount,

rowValueDifferRange,colValueDifferRange,

randArray,

currentRow,currentCol);

}

// 根据求出的范围生成随机数

else

{

// 生成当前的随机数

randArray[currentRow][currentCol] =

rand()%(currentValueRange.upper - currentValueRange.lower) +

currentValueRange.lower;

}

}

if(currentCol==(colsAmount-1))

{

currentRow++;

currentCol = 0;

}

else

{

currentCol++;

}

// 生成下一个随机数

generate( rowsAmount,colsAmount,

rowValueDifferRange,colValueDifferRange,

randArray,

currentRow,currentCol);

}

int main(int argc, char *argv[])

{

// 随机数组为 5行5列

int rowsAmount=5,colsAmount=5;

//每行的相邻数之差在[-4,4]之间

struct Range rowValueDifferRange={-4,4};

//每列相邻数之差在[-10,10]之间

struct Range colValueDifferRange={-10,10};

// 随机数组

int randArray[MAX_ARRAY_SIZE][MAX_ARRAY_SIZE];

int i,j;

// 重置随机数种子

srand(time(NULL));

generate( rowsAmount,colsAmount,

rowValueDifferRange,colValueDifferRange,

randArray,

0,0);

// 输出随机数组

for(i=0;irowsAmount;i++)

{

for(j=0;jcolsAmount;j++)

printf("%d ",randArray[i][j]);

printf("\n");

}

return 0;

}

/*

23886 23884 23888 23879 23882

23883 23885 23886 23881 23878

23884 23881 23886 23877 23876

23887 23878 23883 23875 23878

23887 23880 23881 23871 23880

*/

C语言编程：编写一个函数，实现矩阵的乘法。

如果确定距阵的大小长度，定义两个二维数组，用两个for循环两数据输入到内存，是每两个for输入一个数组，然后定义另外一个数组，用来得到结果距阵，再用三个嵌套的for将结果放入第三个数组当中，即c[i][j]=a[i][k]+b[k][j],k是在第三重循环，这样就可以得到要求的距阵，如果不确定大小长度就在输入语句的每个for循环的辖区内加一个变量作为标记程序运行时求出距阵的大小

c语言子函数返回一个矩阵

代码没看出问题，可能是你打印的时候打印得不对，上面的代码没有做打印动作。

数据结构（使用C语言）关于矩阵

你的测试数据不符合条件，不是对称矩阵。但函数调试已调试好了，无误。

#include stdio.h

#define N 3

#define M (N*N+N)/2

void add(int C[],int A[],int B[])

{

for(int i=0;iM;i++)

C[i]=A[i]+B[i];

}

void print(int C[])

{

int i,j,t;

for(i=0;iN;i++)

{

for(int j=0;jN;j++)

{

if(i=j) t=(i+1)*i/2+j;

else t=(j+1)*j/2+i; //下三角存储

printf("%d ",C[t]);

}

printf("\n");

}

}

int main(void)

{

int a[N][N]={{1,2,3},{10,20,30},{2,4,5}};

int b[N][N]={{20,40,50},{3,5,6},{30,50,60}};

int A[M],B[M],C[M];

int i,j,t=0,k=0;

for(i=0;i=2;i++)

for(j=0;j=i;j++)

{

A[t++]=a[i][j];

B[k++]=b[i][j];

}

add(C,A,B);

print(C);

return 0;

}

用C语言编写一个矩阵运算的程序，高分！

//矩阵三元组之矩阵相加 相乘

#include iostream

using namespace std;

typedef int Elemtype;

#define MAXSIZE 12500 //最大非零元素

typedef struct Triple

{

Elemtype value;

int row,col;

}Triple;

typedef struct TSMatrix

{

Triple data[MAXSIZE+1];

int mu,nu,tu;

}TSMatrix;

TSMatrix T;

void InputMatrix(TSMatrix T) //输入t个非零元素

{

cout"请输入稀疏矩阵的信息,(行，列，非零元素个数)"endl;

cinT.muT.nuT.tu;

int i;

cout"请输入非零元素的信息(行，列，值),提醒(下标从1开始)"endl;

for(i=1;i=T.tu;++i)

{

cinT.data[i].rowT.data[i].colT.data[i].value;

}

}

void Output(TSMatrix T)

{

cout"矩阵的三元组表示(ROW=)"T.mu" COL="T.nu"非零个数="T.tuendl;

int i;

for(i=1;i=T.tu;++i)

{

cout"ROW(行):"T.data[i].row" COL(列):"T.data[i].col" Value(值)"T.data[i].valueendl;

}

}

void TransposeSMatrix(TSMatrix M,TSMatrix T) //矩阵的转置

{

T.mu=M.nu;T.nu=M.mu;T.tu=M.tu;

int i,j,k=1;

for(i=1;i=M.nu;++i)

{

for(j=1;j=M.tu;++j)

if(M.data[j].col==i)

{

T.data[k].row=i;

T.data[k].col=M.data[j].row;

T.data[k].value=M.data[j].value;

++k;

}

}

}

void AddMastrix(TSMatrix M,TSMatrix T,TSMatrix Q) //矩阵相加

{

int index_a,index_b,i=1,j=1,k=1;

Q.mu=M.mu; Q.nu=M.nu;

while (i=M.tuj=T.tu)

{

index_a=(M.data[i].row)*(M.data[i].col)+M.data[i].col;

index_b=(T.data[j].row)*(T.data[j].col)+T.data[j].col;

if(index_aindex_b)

{

Q.data[k]=M.data[i];

i++;

k++;

}

else if(index_aindex_b)

{

Q.data[k]=T.data[j];

j++;

k++;

}

else if(index_a==index_b)

{

if((M.data[i].value+T.data[j].value)!=0)

{

Q.data[k]=M.data[i];

Q.data[k].value=M.data[i].value+T.data[j].value;

k++;

}

++i;

++j;

}

}

//复制剩余元素

for(;i=M.tu;++i)

{

Q.data[k]=M.data[i];

k++;

}

for(;j=T.tu;++j)

Q.data[k++]=T.data[j];

Q.tu=k-1;

}

void Multiply(TSMatrix M,TSMatrix T,TSMatrix Q) //相乘

{

if(M.nu!=T.mu)

{

cerr"两矩阵相乘不合法"endl;

return ;

}

int *rowSize=new int[T.mu+1]; //存放每行非零元素的个数

int *rowStart=new int[T.mu+2]; //矩阵每行在三元组开始位置

int *temp=new int[T.nu+1]; //存放结果矩阵中每行的计算结果

int i,Current,k,ROWM,COLM,COLB;

for(i=1;i=T.mu;i++) rowSize[i]=0;

for(i=1;i=T.tu;++i) rowSize[T.data[i].row]++;

rowStart[1]=1;

for(i=2;i=T.mu+1;i++)

rowStart[i]=rowStart[i-1]+rowSize[i-1];

Current=1; k=1;

while (Current=M.tu)

{

ROWM=M.data[Current].row; //当前三元组数据中元素的行号

for(i=1;i=T.nu;++i) temp[i]=0;

while (Current=M.tuROWM==M.data[Current].row)

{

COLM=M.data[Current].col; //当前元素的列号，方便与T矩阵的行号相乘

for(i=rowStart[COLM];irowStart[COLM+1];i++) //对应T矩阵中每行的个数

{

COLB=T.data[i].col;

temp[COLB]+=(M.data[Current].value)*(T.data[i].value);

}

Current++;

}

for(i=1;i=T.nu;i++)

{

if(temp[i]!=0)

{

Q.data[k].row=ROWM;

Q.data[k].col=i;

Q.data[k].value=temp[i];

}

k++;

}

}

Q.mu=M.mu;Q.nu=T.nu;

Q.tu=k-1;

}

int main()

{

TSMatrix T,M,Q,S;

InputMatrix(M);

InputMatrix(T);

cout"两矩阵相乘"endl;

Multiply(M,T,Q);

Output(Q);

cout"两矩阵相加"endl;

AddMastrix(M,M,S);

Output(S);

system("pause");

return 0;

}