《软件技术基础》实验指导 实验四

Posted 2020-10-15

数组

实验四 数组

一、实验目的

1. 熟悉数组的结构

2. 掌握矩阵的压缩存储

3. 能够对数组和矩阵的压缩存储进行运算

二、实验内容

1. 若在矩阵\(A_{m\times n}\)中存在一个元素A[i][j]，其满足A[i][j]是第i行元素中最小值，且又是第j列元素中最大值，则称此元素为该矩阵的一个马鞍点。用二维数组存储矩阵\(A_{m\times n}\)，设计算法求出矩阵中所有马鞍点。

2. A和B是两个n×n阶的对称矩阵，以行为主序输入对称矩阵的下三角元素，压缩存储存入一维数组A和B，编写一个算法计算对称矩阵A和B的乘积，结果存入二维数组C。

Tips

1. 寻找马鞍点，依次搜索法：遍历每个元素判断是否满足马鞍点条件。

2. 寻找马鞍点，多马鞍点相等法：分别求出每行最小数和每列最大数存在min和max中，当同序号数组元素相等时即为马鞍点。

3. 对称矩阵压缩读入，根据行列提取到row和col数组，再相乘得元素值，使用循环遍历进行操作即可。

Answer

4.1

//找马鞍点程序代码
#include<stdio.h>
//#include<malloc.h>
#include<stdlib.h>
//数组的结构类型定义
const int m=3;
const int n=3;
typedef struct{
    int A[m+1][n+1];
    int max[m+1],min[n+1];
}array;
//数组从1开始
void minmax(array*);
void minmax2(array*);

//void main()
int main()
{
    array*pa=(array*)malloc(sizeof(array));
    int i, j;
    for (i=1;i<=m;i++)
    {
        for (j=1;j<=n;j++)
        {
            scanf("%d",&pa->A[i][j]);
        }
    }
    minmax2(pa);
    return 0;
}

//依次搜索法
void minmax(array*pa)
{
    int IsRowMax(int A[m+1][n+1],int i,int j);
    int IsColMin(int A[m+1][n+1],int i,int j);
    int i,j,flag = 0;
    //采用嵌套for结构，遍历每个元素，判断是否是鞍点
    for (i = 1; i <= m; i++)
    {
        for (j = 1; j <= n; j++)
        {
            //两个条件都为真，说明该点是鞍点
            if (IsRowMax(pa->A,i,j) && IsColMin(pa->A,i,j))
            {
                printf("鞍点为：a[%d][%d]=%d\n",i,j,pa->A[i][j]);
                flag = 1;
            }
        }
    }
    if (!flag)
    {
        printf("没有鞍点\n");
    }
}

//判断是否是行最小，行号i不变，列号j变化
int IsRowMax(int A[m+1][n+1],int i,int j)
{
    int k, s = 1;
    for (k = 1; k <= n; k++)
    {
        //只要一行中，有一个元素小于指定元素，那么该元素就不是改行中的最小值，返回0，结束循环比较
        if (A[i][k] < A[i][j])
        {
            s = 0;
            break;
        }
    }
    return s;
}

//判断是否为列最大，行号i变化，列号j不变
int IsColMin(int A[m+1][n+1], int i, int j)
{
    int k, s = 1;
    for (k = 1; k <= m; k++)
    {
        //只要一列中，有一个元素大于指定元素，那么该元素就不是该列的最大值，返回0，结束循环比较
        if (A[k][j] > A[i][j])
        {
            s = 0;
            break;
        }
    }
    return s;
}

//多马鞍点相等法
void minmax2(array*pa)
{

    void GetMin(array*pa);
    void GetMax(array*pa);
    int i,j,flag = 0;
    GetMin(pa);
    GetMax(pa);
    for(i=1; i<=m; i++)
    {
        for(j=1; j<=n; j++)
        {
            //找到马鞍点
            if(pa->min[i] == pa->max[j])
            {
                printf("鞍点为：a[%d][%d]=%d\n",i,j,pa->A[i][j]);
                flag = 1;
            }
        }
    }
    if(!flag)
    {
        printf("没有鞍点\n");
    }
}

//求出每行最小数，存在min中
void GetMin(array*pa)
{
    int i,j;
    for(i=1; i<=m; i++)
    {
        pa->min[i]=pa->A[i][1];
        for(j=1; j<=n; j++)
        {
            if(pa->min[i]>pa->A[i][j])
            {
                pa->min[i]=pa->A[i][j];
            }
        }
    }
}

//求出每列最大数，存在max中
void GetMax(array*pa)
{
    int i,j;
    for(j=1; j<=n; j++)
    {
        pa->max[j]=pa->A[1][j];
        for(i=1; i<=m; i++)
        {
            if(pa->max[j]<pa->A[i][j])
            {
                pa->max[j]=pa->A[i][j];
            }
        }
    }
}

4.2

//对称矩阵相乘的程序代码
#include<stdio.h>
//#include<malloc.h>
#include<stdlib.h>
//数组结构类型的定义.h
const int n=3;
const int size=n*(n+1)/2;
typedef int datatype;
typedef struct{
    datatype A[size],B[size],C[n][n];
}array;

void input(datatype[]);
void output(datatype[][n]);
void mult(array*);

//void main()
int main()
{
    array*pa;
    pa=(array*)malloc(sizeof(array));
    printf("以行为主序输入矩阵A的下三角:\n");
    input(pa->A);//以行为主序输入矩阵A的下三角
    printf("以行为主序输入矩阵B的下三角:\n");
    input(pa->B);//以行为主序输入矩阵B的下三角
    mult(pa);
    output(pa->C);//输出矩阵C
    return 0;
}

//对称矩阵的输入
void input(datatype x[])
{
    for(int i=0;i<size;i++)
        scanf("%d",&x[i]);
}

//矩阵的输出
void output(datatype x[][n])
{
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++)
            printf("%5d",x[i][j]);
        printf("\n");
    }
}

//对称矩阵相乘
void mult(array*pa)
{
    void take(int pb[],int p[],int j);
    int row[n],col[n];
    int i,j,k,t;
    for(i=0;i<n;i++)
    {
        take(pa->A,row,i);
        for(j=0;j<n;j++)
        {
            take(pa->B,col,j);
            pa->C[i][j]=0;
            for(k=0;k<n;k++)
            {
                //将所得行列相乘得元素值
                pa->C[i][j]+=row[k]*col[k];
            }
        }
    }
}
//将矩阵按照行、列提取到数组
void take(int pb[],int p[],int j)
{
    int i;
    for(i=0;i<n;i++)
    {
        if(i>=j)
        {
            p[i] = pb[i*(i+1)/2+j];
        }
        else
        {
            p[i] = pb[j*(j+1)/2+i];
        }
    }
}