离散数学实践(2)-编程实现关系性质的判断

*本文为博主本人校内的离散数学专业课的实践作业。由于实验步骤已经比较详细,故不再对该实验额外提供详解,本文仅提供填写的实验报告内容与代码部分,以供有需要的同学学习、参考。


编程语言:Java SE

编译环境:jdk 8

相关文章:离散数学实践(1)-编程实现利用真值表法求主析取范式以及主合取范式

目录

一、实验目的

二、实验内容

三、实验步骤及实验结果

1、Java类与接口的设计

(1)设计六个Java类。

(2)类Matrix

(3)类IsReflexive

(4)类IsSymmetry

(5)类IsTransitivity

(6)类Test

2、设计步骤和思路(类TestMain)

3、运行结果

四、总结


一、实验目的

1、理解二元关系的矩阵表示

2、理解二元关系的自反性、反自反性、对称性、反对称性及传递性


二、实验内容

1、用矩阵表示二元关系

2、通过矩阵的特征判断二元关系所具有的性质

3、运用二维数组实现矩阵的输入,然后判断自反性,反自反性,对称性,反对称性,传递性


三、实验步骤及实验结果

1、Java类与接口的设计

(1)设计六个Java类。

包括用于实现四个关系性质判断功能类(类IsReflexive,类IsSymmetry,类IsTransitivity,类Matrix),一个辅助类Test和一个测试类TestMain。

TestMain类中设计main方法,在main方法中搭建程序的主体框架,包括多组输入,实例化Matrix类以访问关系矩阵对象,实例化自反性、传递性与对称性对象。

(2)类Matrix

****定义成员变量:****关系矩阵的阶数n,关系矩阵二维数组array,并设置访问限定修饰符private和protected将n和array封装。构造方法接收main方法传入的矩阵阶数n,并创建数组对象,以存储用户输入的矩阵值。

****定义成员方法:****出于封装的考虑,设计public的方法接口getN()和getArray(),以及矩阵的输出方法,用于在用户输入完毕矩阵后,将矩阵展现出来。输出二维数组也可以调用Arrays.deepToString()完成。

java 复制代码
package com.lisan;

import java.util.Arrays;

public class Matrix {
    private int n;      //阶数
    protected int[][] array;  //矩阵二维数组

    public int getN() {
        return n;
    }

    public Matrix(int n) {
        this.n = n;
        this.array = new int[n][n];
    }

    public int[][] getArray() {

        return array;
    }

    //输出矩阵
    public void printMatrix() {
        System.out.println("关系矩阵为:");
        for (int[] ret : array) {
            for (int x : ret) {
                System.out.print(x + " ");
            }
            System.out.println();
        }
    }
}

(3)类IsReflexive

该类为继承类,继承父类Matrix,以复用Matrix类中的成员。可以理解为:一个自反关系类,可以实例化出一个自反关系对象。

定义成员变量: reflexive(自反),antiReFlexive(反自反)。初始值均为false。

定义成员方法:

public boolean isRef():用于判断关系是否为自反性。根据输入只能为0或1两个值,因此自反矩阵的主对角线元素值均为1。遍历二维数组,用flag标记该关系的主对角线值是否均为1.若均为1,则更改reflexive属性为true,意为该关系是自反性的;否则reflexive仍为false。最终将属性reflexive值返回。

public boolean isAntiRef():用于判断关系是否为反自反性。思路同上,反自反矩阵的主对角线元素值均为0.遍历二维数组,用flag标记该关系的主对角线值是否均为0.若均为0,则更改antiReFlexive属性为true,意为该关系是反自反性的;否则antiReFlexive仍为false。最终将属性antiReFlexive值返回。

java 复制代码
package com.lisan;

public class IsReflexive extends Matrix {
    boolean reflexive;  //自反性
    boolean antiReflexive;  //反自反性

    public IsReflexive(int n,int[][] array) {
        super(n);
        super.array = array;
    }

    public boolean isRef() {
        boolean flag = true;
        //自反矩阵主对角线元素全为1
        for (int i = 0; i < array.length; i++) {
            if (array[i][i] != 1) {
                flag = false;
                break;
            }
        }

        if (flag) {
            this.reflexive = true; //是自反的
        }
        return this.reflexive;
    }

    public boolean isAntiRef() {
        boolean flag = true;
        //反自反矩阵主对角线元素全为0
        for (int i = 0; i < array.length; i++) {
            if (array[i][i] != 0) {
                flag = false;
                break;
            }
        }
        if (flag) {
            this.antiReflexive = true; //是反自反的
        }
        return this.antiReflexive;
    }
}

(4)类IsSymmetry

该类同样继承父类Matrix。可以理解为:一个对称关系类。

****定义成员变量:****symmetry(对称),skewSymmetry(反对称)。初始值均为false。

定义成员方法:

public boolean isSymmetry() :用于判断关系是否为对称性。遍历二维数组,用flag标记该关系对称矩阵array[i][j] == array[j][i].若成立,则更改symmetry属性为true,意为该关系是对称性的;否则symmetry仍为false。最终将属性this.symmetry值返回。

public boolean isAntiSymmetry():用于判断关系是否为反对称性。在反对称矩阵中,i != j时,array[i][j]和array[j][i]不同时为1。遍历二维数组,用flag标记反对称条件是否成立。若成立,则更改this.skewSymmetry属性为true,意为该关系是反对称性的;否则仍为false。最终将this.skewSymmetry值返回。

java 复制代码
package com.lisan;

public class IsSymmetry extends Matrix {
    boolean symmetry;   //对称性
    boolean skewSymmetry;  //反对称性

    public IsSymmetry(int n,int[][] array) {
        super(n);
        super.array = array;
    }

    public boolean isSymmetry() {
        boolean flag = true;
        //对称矩阵array[i][j] == array[j][i]
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j] != array[j][i]) {
                    flag = false;
                    break;
                }
            }
        }
        if(flag) {
            this.symmetry = true;
        }
        return this.symmetry;
    }

    public boolean isAntiSymmetry() {
        boolean flag = true;
        //反对称矩阵中i != j时,array[i][j]和array[j][i]不同时为1
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(i != j) {
                    if (array[i][j] == 1 && array[j][i] == 1) {
                        flag = false;
                        break;
                    }
                }
                if(!flag) {
                    break;
                }
            }
        }
        if(flag) {
            this.skewSymmetry = true;
        }
        return this.skewSymmetry;
    }
}

(5)类IsTransitivity

该类同样继承父类Matrix。可以理解为:一个对传递关系类。

****定义成员变量:****transitivity(传递)。初始值均为false。

定义成员方法:

public boolean isTransitivity() :用于判断关系是否为传递性。已知在传递矩阵中,若array[i][j]==1且array[j][k]==1,则a[i][k]也为1。遍历二维数组,用flag标记该关系对称矩阵是否满足传递性的条件。若成立,则更改transitivity属性为true,意为该关系是传递的;否则transitivity仍为false。最终将属性this.transitivity值返回。

java 复制代码
package com.lisan;

public class IsTransitivity extends Matrix{
    boolean transitivity;   //传递性

    public IsTransitivity(int n,int[][] array) {
        super(n);
        super.array = array;
    }

    public boolean isTransitivity() {
        int n = getN();
        boolean flag = true;
        //传递矩阵若array[i][j]==1且array[j][k]==1,则a[i][k]也为1
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                for (int l = 0; l < n; l++) {
                    if (array[i][j] == 1 && array[j][l] == 1) {
                        if(array[i][l] != 1) {
                            flag = false;
                            break;
                        }
                    }
                }
                if(!flag) {
                    break;
                }
            }
            if(!flag) {
                break;
            }
        }
        if(flag) {
            this.transitivity = true;
        }
        return transitivity;
    }
}

(6)类Test

该类用于依次测试各个类功能与接口是否能正常运行,不作为最终的实验功能实现。

2、设计步骤和思路(类TestMain)

(1)输入矩阵真值

在main方法中进行输入。首先输入关系矩阵阶数n,再实例化Matrix对象,构造一个n阶的二维数组。调用matrix.getArray()方法接收创建的数组对象的引用。

然后用户输入关系中的真值。规定:只能输入0或1.检查用户输入是否有误,若有则提示用户重新输入正确的值。

(2)输出用户输入的数组值。

(3)实例化自反关系对象:IsReflexive ref = new IsReflexive(n,array);传入阶数n与引用array,调用ref的成员方法,依次判断ref是否为自反关系、反自反关系。若ref.reflexive和ref.antiReflexive均为false,则说明它既不是自反关系也不是反自反关系。输出结果。

(4)实例化对称关系对象与传递关系对象。同理,分别调用对象的成员方法,依次判断它是否为对称关系、反对称关系、传递关系。若对称关系判断中symmetry和skewSymmetry均为false,则说明它既不是对称关系也不是反对称关系。输出结果。

java 复制代码
package com.lisan;
import java.util.Scanner;

public class TestMain {
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
            //输入关系矩阵
            System.out.println("请输入关系矩阵阶数:");
            int n = reader.nextInt();
            Matrix matrix = new Matrix(n);
            int[][] array = matrix.getArray();

            System.out.println("请输入关系矩阵R (0或1):");

            for (int i = 0; i < array.length; i++) {
                for (int j = 0; j < array[i].length; j++) {
                    array[i][j] = reader.nextInt();
                    while(array[i][j] != 0 && array[i][j] != 1) {
                        System.out.println("输入有误!重新输入!");
                        array[i][j] = reader.nextInt();
                    }
                }
            }
            //System.out.println(matrix);
            matrix.printMatrix();
            //System.out.println(Arrays.deepToString(array));
            System.out.print("是否自反:");
            IsReflexive ref = new IsReflexive(n,array);
            if(ref.isRef()) {
                System.out.println("自反关系!");
            } else if(ref.isAntiRef()) {
                System.out.println("反自反关系!");
            } else {
                System.out.println("既不自反也不反自反!");
            }

            System.out.print("是否对称:");
            IsSymmetry sym = new IsSymmetry(n,array);
            if(sym.isSymmetry()) {
                System.out.println("对称关系!");
            } else if (sym.isAntiSymmetry()) {
                System.out.println("反对称关系!");
            } else {
                System.out.println("既不对称也不反对称!");
            }

            System.out.print("是否传递:");
            IsTransitivity tran = new IsTransitivity(n,array);
            if(tran.isTransitivity()) {
                System.out.println("传递关系!");
            } else {
                System.out.println("不是传递关系!");
            }
        }
}

3、运行结果

四、总结

  1. 经过编程,从代码的角度考虑离散数学问题,更熟练地掌握了关系性质判断的原理。
  2. Java类面向对象的思维得到了很好的体现。
  3. 自反:主对角线元素全是1
  4. 反自反:主对角线元素全是0
  5. 对称:矩阵是对称矩阵(R的逆等于R)
  6. 反对称:若rij=1, 且i≠j, 则rji=0
  7. 传递:对M2中1所在位置,M中相应位置都是1

经过实践作业,对以上离散数学知识点的理解更为深入了。可以与对书本上的书面作业融会贯通。

相关推荐
朝九晚五ฺ5 小时前
【Linux探索学习】第十四弹——进程优先级:深入理解操作系统中的进程优先级
linux·运维·学习
猫爪笔记6 小时前
前端:HTML (学习笔记)【1】
前端·笔记·学习·html
pq113_67 小时前
ftdi_sio应用学习笔记 3 - GPIO
笔记·学习·ftdi_sio
澄澈i7 小时前
设计模式学习[8]---原型模式
学习·设计模式·原型模式
爱米的前端小笔记8 小时前
前端八股自学笔记分享—页面布局(二)
前端·笔记·学习·面试·求职招聘
alikami8 小时前
【前端】前端学习
学习
一只小菜鸡..8 小时前
241118学习日志——[CSDIY] [ByteDance] 后端训练营 [06]
学习
Hacker_Oldv10 小时前
网络安全的学习路线
学习·安全·web安全
蒟蒻的贤10 小时前
vue学习11.21
javascript·vue.js·学习
高 朗10 小时前
【GO基础学习】基础语法(2)切片slice
开发语言·学习·golang·slice