Java学习第32天-34天_[0,0,1]格式的java数据怎么实现-CSDN博客

本文链接：https://blog.csdn.net/xiaowuPHD/article/details/118194037

Java学习第32天：图的连通性检测

1.什么是结点的连通性？

若图 G 中两个不同的结点 u 和 v 存在路径 e，则称结点 u 和结点 v 连通。

2.什么是图的连通性？

若图 G 中任意两个结点连通，则称图 G 连通。

检测原理：

适用于有向图. 反正无向图是有向图的特殊形式；0 次方的时候是单位矩阵；为每一个方法写一个独立的测试方法. 测试代码有时比正常使用的代码更多；第一个测试用例是无向图, 第二个是有向图.可以看到, 后者从节点 1 不能到达节点 0.

代码如下：

package day32to35;
import day31.IntMatrix;
public class Graph {
	//连通矩阵
    IntMatrix connectivityMatrix;


    /**
    * @Description: 第一个构造函数
    * @Param: [paraNumNodes]
    * @return:
    */
    public Graph(int paraNumNodes) {
        connectivityMatrix = new IntMatrix(paraNumNodes, paraNumNodes);
    }

    /**
    * @Description: 第二个构造函数
    * @Param: [paraMatrix]
    * @return:
    */
    public Graph(int[][] paraMatrix) {
        connectivityMatrix = new IntMatrix(paraMatrix);
    }


    public String toString() {
        String resultString = "This is the connectivity matrix of the graph.\r\n"
                + connectivityMatrix;
        return resultString;
    }

    /**
    * @Description: 判断连通性
    * @Param: []
    * @return: boolean
    */
    public boolean getConnectivity() throws Exception {
        // 首先初始化一个单位矩阵
        IntMatrix tempConnectivityMatrix = IntMatrix
                .getIdentityMatrix(connectivityMatrix.getData().length);

        // 初始化目标矩阵
        IntMatrix tempMultipliedMatrix = new IntMatrix(connectivityMatrix);

        // 计算矩阵
        for (int i = 0; i < connectivityMatrix.getData().length - 1; i++) {

            tempConnectivityMatrix.add(tempMultipliedMatrix);


            tempMultipliedMatrix = IntMatrix.multiply(tempMultipliedMatrix, connectivityMatrix);
        }

        // 判断连通性
        System.out.println("The connectivity matrix is: " + tempConnectivityMatrix);
        int[][] tempData = tempConnectivityMatrix.getData();
        for (int i = 0; i < tempData.length; i++) {
            for (int j = 0; j < tempData.length; j++) {
                if (tempData[i][j] == 0) {
                    System.out.println("Node " + i + " cannot reach " + j);
                    return false;
                }
            }
        }

        return true;
    }


    /**
    * @Description: 测试
    * @Param: []
    * @return: void
    */
    public static void getConnectivityTest() {
        // 测试一个非连通图
        int[][] tempMatrix = { { 0, 1, 0 }, { 1, 0, 1 }, { 0, 1, 0 } };
        Graph tempGraph2 = new Graph(tempMatrix);
        System.out.println(tempGraph2);

        boolean tempConnected = false;
        try {
            tempConnected = tempGraph2.getConnectivity();
        } catch (Exception e) {
            System.out.println(e);
        }

        System.out.println("Is the graph connected? " + tempConnected);

        // 测试一个连通图
        tempGraph2.connectivityMatrix.setValue(1, 0, 0);

        tempConnected = false;
        try {
            tempConnected = tempGraph2.getConnectivity();
        } catch (Exception e) {
            System.out.println(e);
        }

        System.out.println("Is the graph connected? " + tempConnected);
    }


    public static void main(String args[]) {

        Graph tempGraph = new Graph(3);
        System.out.println(tempGraph);

        getConnectivityTest();
    }
}

运行结果：

This is the connectivity matrix of the graph.
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
This is the connectivity matrix of the graph.
[[0, 1, 0], [1, 0, 1], [0, 1, 0]]
The connectivity matrix is: [[2, 1, 1], [1, 3, 1], [1, 1, 2]]
Is the graph connected? true
The connectivity matrix is: [[1, 1, 1], [0, 2, 1], [0, 1, 2]]
Node 1 cannot reach 0
Is the graph connected? false

注：需要自己理解有向图和无向图的区别，还有邻接矩阵和关联矩阵的不同概念。本文中连通矩阵就是邻接矩阵。

Java学习第33天：图的广度优先遍历

图的遍历，所谓遍历，即是对结点的访问。广度优先遍历简称BFS，类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点。

具体算法表述如下：

访问初始结点v并标记结点v为已访问。
结点v入队列
当队列非空时，继续执行，否则算法结束。
出队列，取得队头结点u。
查找结点u的第一个邻接结点w。
若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤：
1). 若结点w尚未被访问，则访问结点w并标记为已访问。
2). 结点w入队列
3). 查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。

如下图，其广度优先算法的遍历顺序为：1->2->3->4->5->6->7->8

代码如下：

/**
     * @Description: 广度优先遍历
     * @Param: [paraStartIndex]
     * @return: java.lang.String
    */
    public String breadthFirstTraversal(int paraStartIndex) {
        CircleObjectQueue tempQueue = new CircleObjectQueue();
        String resultString = "";

        int tempNumNodes = connectivityMatrix.getRows();
        boolean[] tempVisitedArray = new boolean[tempNumNodes];

        tempVisitedArray[paraStartIndex] = true;


        tempVisitedArray[paraStartIndex] = true;
        resultString += paraStartIndex;
        tempQueue.enqueue(paraStartIndex);


        int tempIndex;
        Integer tempInteger = (Integer)tempQueue.dequeue();
        while (tempInteger != null) {
            tempIndex = tempInteger.intValue();


            for (int i = 0; i < tempNumNodes; i ++) {
                if (tempVisitedArray[i]) {
                    continue;
                }

                if (connectivityMatrix.getData()[tempIndex][i] == 0) {
                    continue;
                }


                tempVisitedArray[i] = true;
                resultString += i;
                tempQueue.enqueue(i);
            }


            tempInteger = (Integer)tempQueue.dequeue();
        }

        return resultString;
    }


    /**
    * @Description: 测试广度优先遍历
    * @Param: []
    * @return: void
    */
    public static void breadthFirstTraversalTest() {
        // 测试一个非连通图
        int[][] tempMatrix = { { 0, 1, 1, 0 }, { 1, 0, 0, 1 }, { 1, 0, 0, 1}, { 0, 1, 1, 0} };
        Graph tempGraph = new Graph(tempMatrix);
        System.out.println(tempGraph);

        String tempSequence = "";
        try {
            tempSequence = tempGraph.breadthFirstTraversal(0);
        } catch (Exception e) {
            System.out.println(e);
        }

        System.out.println("The breadth first order of visit: " + tempSequence);
    }

运行结果：

This is the connectivity matrix of the graph.
[[0, 1, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 1, 0]]
The breadth first order of visit: 0123

注：调用了第22天二叉树的储存（层次遍历）。

Java学习第34天：图的深度优先遍历

深度优先遍历简称DFS，从初始访问结点出发，我们知道初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点。总结起来可以这样说：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。我们从这里可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。

具体算法表述如下：

访问初始结点v，并标记结点v为已访问。
查找结点v的第一个邻接结点w。
若w存在，则继续执行4，否则算法结束。
若w未被访问，对w进行深度优先遍历递归（即把w当做另一个v，然后进行步骤123）。
查找结点v的w邻接结点的下一个邻接结点，转到步骤3。

例如下图，其深度优先遍历顺序为 1->2->4->8->5->3->6->7

代码如下：

/**
     * @Description: 深度遍历
     * @Param: [paraStartIndex]
     * @return: java.lang.String
     */
    public String depthFirstTraversal(int paraStartIndex) {
        ObjectStack tempStack = new ObjectStack();
        String resultString = "";

        int tempNumNodes = connectivityMatrix.getRows();
        boolean[] tempVisitedArray = new boolean[tempNumNodes];

        tempVisitedArray[paraStartIndex] = true;


        tempVisitedArray[paraStartIndex] = true;
        resultString += paraStartIndex;
        tempStack.push(paraStartIndex);
        System.out.println("Push " + paraStartIndex);
        System.out.println("Visited " + resultString);


        int tempIndex = paraStartIndex;
        int tempNext;
        Integer tempInteger;
        while (true) {
            //找到最近的节点
            tempNext = -1;
            for (int i = 0; i < tempNumNodes; i++) {
                if (tempVisitedArray[i]) {
                    continue;
                }

                if (connectivityMatrix.getData()[tempIndex][i] == 0) {
                    continue;
                }


                tempVisitedArray[i] = true;
                resultString += i;
                tempStack.push(i);
                System.out.println("Push " + i);
                tempNext = i;

                break;
            }


            if (tempNext == -1) {
                //没有最近节点后返回到上一节点去寻找最近节点
                if (tempStack.isEmpty()) {
                    break;
                }
                tempInteger = (Integer) tempStack.pop();
                System.out.println("Pop " + tempInteger);
                tempIndex = tempInteger.intValue();
            } else {
                tempIndex = tempNext;
            }
        }

        return resultString;
    }

    /**
     * @Description: 深度遍历测试
     * @Param: []
     * @return: void
     */
    public static void depthFirstTraversalTest() {
        // 测试一个非连通图
        int[][] tempMatrix = {{0, 1, 1, 0}, {1, 0, 0, 1}, {1, 0, 0, 0}, {0, 1, 0, 0}};
        Graph tempGraph = new Graph(tempMatrix);
        System.out.println(tempGraph);

        String tempSequence = "";
        try {
            tempSequence = tempGraph.depthFirstTraversal(0);
        } catch (Exception e) {
            System.out.println(e);
        }

        System.out.println("The depth first order of visit: " + tempSequence);
    }

运行结果：

This is the connectivity matrix of the graph.
[[0, 1, 1, 0], [1, 0, 0, 1], [1, 0, 0, 0], [0, 1, 0, 0]]
Push 0
Visited 0
Push 1
Push 3
Pop 3
Pop 1
Pop 0
Push 2
Pop 2
The depth first order of visit: 0132

注：调用了第25天二叉树深度遍历的栈实现 (中序遍历)。